1

README: Remove 奶牛快传(cowtransfer) references

.cursorrules

@@ -1,346 +0,0 @@
-# NetDisk Fast Download - Agent 规则文件
-
-## 项目概述
-网盘快速下载项目，支持多种网盘链接解析和下载加速。
-
-## 技术栈
-
-### 后端
-- **Java 版本**: JDK 17
-- **构建工具**: Maven 3.x
-- **核心框架**: Vert.x 4.5.23
-- **日志框架**: SLF4J 2.0.5 + Logback 1.5.19
-- **工具库**: 
-  - Lombok 1.18.38
-  - Apache Commons Lang3 3.18.0
-  - Apache Commons BeanUtils 2.0.0
-  - Jackson 2.14.2
-  - Reflections 0.10.2
-
-### 前端
-- Vue.js 框架
-- Monaco Editor (代码编辑器)
-
-### 测试
-- JUnit 4.13.2
-- **Maven 测试配置**: 默认跳过测试，使用 `-Dmaven.test.skip=false` 执行测试
-
-## 项目模块结构
-
-```
-netdisk-fast-download/
-├── core/              # 核心功能模块
-├── core-database/     # 数据库模块
-├── parser/            # 解析器模块（支持自定义解析器）
-├── web-service/       # Web 服务模块
-└── web-front/         # 前端模块
-```
-
-## 编码规范
-
-### Java 代码规范
-1. **使用 Lombok 注解简化代码**
-   - `@Data`, `@Getter`, `@Setter`, `@Builder` 等
-   - `@Slf4j` 用于日志
-
-2. **异步编程**
-   - 使用 Vert.x 的 Future/Promise 模式
-   - 遵循响应式编程范式
-   - 避免阻塞操作
-
-3. **日志规范**
-   - 使用 SLF4J + Logback
-   - 日志级别：ERROR（错误）、WARN（警告）、INFO（重要信息）、DEBUG（调试信息）
-   - 日志文件按日期分目录存储在 `logs/` 下
-
-4. **包命名规范**
-   - 基础包名：`cn.qaiu`
-   - 子包按模块功能划分
-
-### 测试规范
-1. **默认跳过测试**: 打包时使用 `mvn clean package`
-2. **执行测试**: 使用 `mvn test -Dmaven.test.skip=false`
-3. 测试类放在 `src/test/java` 目录下
-
-### Core 模块封装（禁止重复造轮子）
-
-#### Web 路由封装
-**核心类**: `cn.qaiu.vx.core.handlerfactory.RouterHandlerFactory`
-
-使用注解方式定义路由，无需手动创建 Router：
-```java
-// ✅ 推荐：使用注解定义路由
-@RouteHandler("/api")  // 类级别路由前缀
-@Slf4j
-public class MyController {
-    
-    @RouteMapping(value = "/users", method = RouteMethod.GET)
-    public Future<List<User>> getUsers() {
-        // 返回 Future，框架自动处理响应
-        return userService.findAll();
-    }
-    
-    @RouteMapping(value = "/user/:id", method = RouteMethod.GET)
-    public Future<User> getUserById(String id) {
-        // 路径参数自动注入
-        return userService.findById(id);
-    }
-    
-    @RouteMapping(value = "/user", method = RouteMethod.POST)
-    public Future<JsonResult<User>> createUser(HttpServerRequest request, String name, Integer age) {
-        // 查询参数自动注入
-        return userService.create(name, age)
-            .map(JsonResult::success);
-    }
-}
-
-// ❌ 避免：手动创建路由
-Router router = Router.router(vertx);
-router.get("/api/users").handler(ctx -> {
-    // 不要这样写
-});
-```
-
-**支持的注解：**
-- `@RouteHandler(value="/path", order=0)` - 标记路由处理类
-- `@RouteMapping(value="/path", method=RouteMethod.GET)` - 标记路由方法
-- `@SockRouteMapper("/ws")` - WebSocket 路由
-
-**自动参数注入：**
-- `HttpServerRequest` - 请求对象
-- `HttpServerResponse` - 响应对象  
-- `RoutingContext` - 路由上下文
-- `String param` - 路径参数或查询参数（自动匹配名称）
-- 自定义对象 - 自动从请求体反序列化
-
-#### 响应处理工具
-**工具类**: `cn.qaiu.vx.core.util.ResponseUtil`
-
-```java
-// ✅ 推荐：使用 ResponseUtil
-ResponseUtil.redirect(response, "https://example.com");
-ResponseUtil.fireJsonObjectResponse(ctx, jsonObject);
-ResponseUtil.fireJsonResultResponse(ctx, JsonResult.success(data));
-
-// ❌ 避免：手动设置响应头
-response.putHeader("Content-Type", "application/json");
-response.end(json);
-```
-
-#### 统一响应模型
-**模型类**: `cn.qaiu.vx.core.model.JsonResult<T>`
-
-```java
-// ✅ 推荐：使用 JsonResult 统一响应格式
-public Future<JsonResult<User>> getUser(String id) {
-    return userService.findById(id)
-        .map(JsonResult::success)  // 成功响应
-        .otherwise(err -> JsonResult.error(err.getMessage()));  // 错误响应
-}
-
-// 响应格式：
-// {"code": 200, "msg": "success", "success": true, "data": {...}, "timestamp": 123456789}
-```
-
-#### 异步服务代理
-**工具类**: `cn.qaiu.vx.core.util.AsyncServiceUtil`
-
-```java
-// ✅ 推荐：使用服务代理
-private final UserService userService = AsyncServiceUtil.getAsyncServiceInstance(UserService.class);
-
-// ❌ 避免：手动管理服务实例和 EventBus
-```
-
-### Core-Database 模块封装（禁止重复造轮子）
-
-#### DDL 自动生成
-**核心类**: `cn.qaiu.db.ddl.CreateTable`
-
-使用注解定义实体，自动生成建表 SQL：
-```java
-// ✅ 推荐：使用注解定义实体
-@Data
-@Table("users")  // 表名
-public class User {
-    @Constraint(autoIncrement = true)
-    private Long id;  // 自动识别为主键
-    
-    @Constraint(notNull = true, uniqueKey = "uk_email")
-    @Length(varcharSize = 100)
-    private String email;
-    
-    @Constraint(notNull = true)
-    private String name;
-    
-    @Constraint(defaultValue = "0", defaultValueIsFunction = false)
-    private Integer status;
-    
-    @Constraint(defaultValue = "NOW()", defaultValueIsFunction = true)
-    private Date createdAt;
-}
-
-// 自动建表
-CreateTable.createTable(pool, JDBCType.MySQL);
-
-// ❌ 避免：手写建表 SQL
-pool.query("CREATE TABLE users (...)").execute();
-```
-
-**支持的注解：**
-- `@Table("tableName")` - 指定表名和主键
-- `@Constraint` - 字段约束
-  - `notNull` - 非空约束
-  - `uniqueKey` - 唯一键约束
-  - `defaultValue` - 默认值
-  - `autoIncrement` - 自增
-- `@Length` - 字段长度
-  - `varcharSize` - VARCHAR 长度
-  - `decimalSize` - DECIMAL 精度
-- `@TableGenIgnore` - 忽略字段（不生成列）
-- `@Column(name="column_name")` - 自定义列名
-
-#### 自动数据库创建
-**工具类**: `cn.qaiu.db.ddl.CreateDatabase`
-
-```java
-// ✅ 推荐：自动创建数据库
-JsonObject dbConfig = config.getJsonObject("database");
-CreateDatabase.createDatabase(dbConfig);
-
-// ❌ 避免：手动连接和执行 SQL
-```
-
-### Parser 模块特殊说明
-1. 支持自定义解析器（Java、Python、JavaScript）
-2. Python 解析器使用 GraalPy 实现
-3. 支持 WebSocket 连接到外部 Python 环境
-4. 包含安全测试和沙箱机制
-
-## Maven 命令
-
-### 常用命令
-```bash
-# 编译打包（跳过测试）
-mvn clean package
-
-# 安装到本地仓库（跳过测试）
-mvn clean install
-
-# 执行测试
-mvn test -Dmaven.test.skip=false
-
-# 编译并执行测试
-mvn clean package -Dmaven.test.skip=false
-
-# 只编译不打包
-mvn clean compile
-
-# 清理
-mvn clean
-```
-
-### 模块化构建
-```bash
-# 只构建特定模块
-mvn clean package -pl parser -am
-
-# 构建多个模块
-mvn clean package -pl core,parser -am
-```
-
-## 部署相关
-
-### 目录结构
-- `bin/`: 启动脚本和服务安装脚本
-- `db/`: 数据库文件
-- `logs/`: 日志文件（按日期分目录）
-- `webroot/`: Web 静态资源根目录
-
-### 脚本文件
-- `run.sh` / `run.bat`: 启动脚本
-- `stop.sh`: 停止脚本
-- `service-install.sh`: Linux 服务安装
-- `nfd-service-install.bat`: Windows 服务安装
-
-## 开发注意事项
-
-1. **字符编码**: 统一使用 UTF-8
-2. **Java 版本**: 必须使用 JDK 17 或更高版本
-3. **Vert.x 异步**: 避免在 Event Loop 线程中执行阻塞操作
-4. **资源文件**: 
-   - 静态资源放在 `webroot/` 目录
-   - 前端构建产物输出到 `web-front/public/`
-5. **日志文件**: 不要提交 `logs/` 目录到版本控制
-6. **测试**: 新增功能必须编写单元测试，使用 `-Dmaven.test.skip=false` 验证
-
-## 代码审查要点
-
-1. 是否正确处理异步操作
-2. 是否有潜在的资源泄漏（连接、文件句柄等）
-3. 异常处理是否完善
-4. 日志记录是否合理
-5. 是否遵循单一职责原则
-6. 是否有适当的注释说明复杂逻辑
-
-## 性能优化建议
-
-1. 使用 Vert.x 的异步特性，避免阻塞
-2. 合理使用缓存机制
-3. 数据库查询优化
-4. 静态资源压缩和缓存策略
-5. 使用连接池管理数据库连接
-
-## 安全注意事项
-
-1. **Parser 模块**: 
-   - 自定义解析器需要经过安全验证
-   - Python/JavaScript 代码执行需要沙箱隔离
-   - 参考 `parser/doc/SECURITY_TESTING_GUIDE.md`
-
-2. **输入验证**: 
-   - 所有外部输入必须验证和清理
-   - 防止注入攻击
-
-3. **敏感信息**: 
-   - 不要在日志中输出敏感信息
-   - 配置文件中的密钥要加密存储
-
-## 文档参考
-
-- Parser 模块文档: `parser/doc/`
-  - API 使用指南: `API_USAGE.md`
-  - 自定义解析器指南: `CUSTOM_PARSER_GUIDE.md`
-  - Python 解析器指南: `PYTHON_PARSER_GUIDE.md`
-  - JavaScript 解析器指南: `JAVASCRIPT_PARSER_GUIDE.md`
-  - 安全测试指南: `SECURITY_TESTING_GUIDE.md`
-
-- 前端文档: `web-front/doc/`
-  - Monaco Editor 集成: `MONACO_EDITOR_NPM.md`
-  - Playground UI 升级: `PLAYGROUND_UI_UPGRADE.md`
-
-## Git 提交规范
-
-使用语义化提交信息：
-- `feat`: 新功能
-- `fix`: 修复 Bug
-- `docs`: 文档更新
-- `style`: 代码格式调整
-- `refactor`: 重构
-- `test`: 测试相关
-- `chore`: 构建/工具链相关
-
-示例：
-```
-feat(parser): 添加新的网盘解析器支持
-fix(core): 修复下载链接过期问题
-docs(readme): 更新安装说明
-```
-
-## AI 助手使用建议
-
-1. 在修改代码前，先理解项目的模块结构和依赖关系
-2. 生成的代码要符合项目现有的编码风格
-3. 涉及异步操作时，优先使用 Vert.x 的 Future/Promise API
-4. 修改配置文件时要考虑向后兼容性
-5. 新增功能时同步更新相关文档

.github/copilot-instructions.md

@@ -1,495 +0,0 @@
-# GitHub Copilot Instructions - NetDisk Fast Download
-
-## 项目简介
-网盘快速下载项目，支持多种网盘链接解析和下载加速的 Java Web 应用。
-
-## 技术栈要求
-
-### 核心技术
-- **Java**: JDK 17（必须）
-- **框架**: Vert.x 4.5.23（异步响应式框架）
-- **构建**: Maven 3.x
-- **日志**: SLF4J 2.0.5 + Logback 1.5.19
-- **前端**: Vue.js + Monaco Editor
-
-### 重要依赖
-- Lombok 1.18.38 - 简化 Java 代码
-- Jackson 2.14.2 - JSON 处理
-- Commons Lang3 3.18.0 - 工具类
-- Reflections 0.10.2 - 反射工具
-
-## 代码生成规范
-
-### Java 代码风格
-
-#### 1. 使用 Lombok 简化代码
-```java
-// ✅ 推荐：使用 Lombok 注解
-@Data
-@Builder
-@Slf4j
-public class Example {
-    private String name;
-    private int value;
-}
-
-// ❌ 避免：手写 getter/setter
-public class Example {
-    private String name;
-    public String getName() { return name; }
-    public void setName(String name) { this.name = name; }
-}
-```
-
-#### 2. 异步编程模式（Vert.x）
-```java
-// ✅ 推荐：使用 Vert.x Future
-public Future<String> fetchData() {
-    return vertx.createHttpClient()
-        .request(HttpMethod.GET, "http://example.com")
-        .compose(HttpClientRequest::send)
-        .compose(response -> response.body())
-        .map(Buffer::toString);
-}
-
-// ❌ 避免：阻塞操作
-public String fetchData() {
-    // 不要在 Event Loop 中执行阻塞代码
-    Thread.sleep(1000); // ❌
-    return result;
-}
-```
-
-#### 3. 日志记录
-```java
-// ✅ 推荐：使用 @Slf4j + 参数化日志
-@Slf4j
-public class Service {
-    public void process(String id) {
-        log.info("Processing item: {}", id);
-        try {
-            // ...
-        } catch (Exception e) {
-            log.error("Failed to process item: {}", id, e);
-        }
-    }
-}
-
-// ❌ 避免：字符串拼接
-log.info("Processing item: " + id); // 性能差
-System.out.println("Debug info"); // 不使用 System.out
-```
-
-#### 4. 异常处理
-```java
-// ✅ 推荐：完整的异常处理
-public Future<Result> operation() {
-    return service.execute()
-        .recover(err -> {
-            log.error("Operation failed", err);
-            return Future.succeededFuture(Result.error(err.getMessage()));
-        });
-}
-
-// ❌ 避免：空的 catch 块或吞掉异常
-try {
-    doSomething();
-} catch (Exception e) {
-    // ❌ 空 catch
-}
-```
-
-### 包和类命名
-
-- 基础包名：`cn.qaiu`
-- 模块包结构：
-  - `cn.qaiu.core.*` - 核心功能
-  - `cn.qaiu.parser.*` - 解析器相关
-  - `cn.qaiu.db.*` - 数据库相关
-  - `cn.qaiu.service.*` - 业务服务
-  - `cn.qaiu.web.*` - Web 相关
-
-### 测试代码
-
-```java
-// ✅ 推荐：JUnit 4 测试
-public class ServiceTest {
-    
-    @Before
-    public void setUp() {
-        // 初始化
-    }
-    
-    @Test
-    public void testMethod() {
-        // Given
-        String input = "test";
-        
-        // When
-        String result = service.process(input);
-        
-        // Then
-        assertEquals("expected", result);
-    }
-    
-    @After
-    public void tearDown() {
-        // 清理
-    }
-}
-```
-
-## 特定模块指导
-
-### Core 模块 - Web 路由封装（必须使用，禁止重复造轮子）
-
-**核心思想：使用注解定义路由，框架自动处理请求和响应**
-
-#### 1. 使用 @RouteHandler 和 @RouteMapping
-```java
-// ✅ 推荐：使用注解定义路由
-@RouteHandler(value = "/api/v1", order = 10)
-@Slf4j
-public class UserController {
-    
-    private final UserService userService = AsyncServiceUtil.getAsyncServiceInstance(UserService.class);
-    
-    // GET /api/v1/users
-    @RouteMapping(value = "/users", method = RouteMethod.GET)
-    public Future<JsonResult<List<User>>> getUsers() {
-        return userService.findAll()
-            .map(JsonResult::success)
-            .otherwise(err -> JsonResult.error(err.getMessage()));
-    }
-    
-    // GET /api/v1/user/:id （路径参数自动注入）
-    @RouteMapping(value = "/user/:id", method = RouteMethod.GET)
-    public Future<User> getUser(String id) {
-        // 返回值自动序列化为 JSON
-        return userService.findById(id);
-    }
-    
-    // POST /api/v1/user （查询参数自动注入）
-    @RouteMapping(value = "/user", method = RouteMethod.POST)
-    public Future<JsonResult<User>> createUser(HttpServerRequest request, String name, Integer age) {
-        return userService.create(name, age)
-            .map(JsonResult::success);
-    }
-    
-    // 重定向示例
-    @RouteMapping(value = "/redirect/:id", method = RouteMethod.GET)
-    public void redirect(HttpServerResponse response, String id) {
-        String targetUrl = "https://example.com/" + id;
-        ResponseUtil.redirect(response, targetUrl);
-    }
-}
-
-// ❌ 避免：手动创建 Router 和 Handler
-Router router = Router.router(vertx);
-router.get("/api/users").handler(ctx -> {
-    // 不要这样写！使用注解方式
-});
-```
-
-#### 2. 自动参数注入规则
-- **路径参数**：`/user/:id` → `public Future<User> getUser(String id)`
-- **查询参数**：`?name=xxx&age=18` → `public Future<User> create(String name, Integer age)`
-- **Vert.x 对象**：自动注入 `HttpServerRequest`, `HttpServerResponse`, `RoutingContext`
-- **请求体**：POST/PUT 的 JSON 自动反序列化为方法参数对象
-
-#### 3. 响应处理
-```java
-// 方式1：返回 Future，框架自动处理
-public Future<User> getUser(String id) {
-    return userService.findById(id);  // 自动序列化为 JSON
-}
-
-// 方式2：返回 JsonResult 统一格式
-public Future<JsonResult<User>> getUser(String id) {
-    return userService.findById(id).map(JsonResult::success);
-}
-
-// 方式3：手动控制响应（仅在特殊情况使用）
-public void customResponse(HttpServerResponse response) {
-    ResponseUtil.fireJsonObjectResponse(response, jsonObject);
-}
-```
-
-#### 4. WebSocket 路由
-```java
-@RouteHandler("/ws")
-public class WebSocketHandler {
-    
-    @SockRouteMapper("/chat")
-    public void handleChat(SockJSSocket socket) {
-        socket.handler(buffer -> {
-            log.info("Received: {}", buffer.toString());
-            socket.write(buffer);  // Echo
-        });
-    }
-}
-```
-
-### Core-Database 模块 - DDL 自动生成（必须使用，禁止重复造轮子）
-
-**核心思想：使用注解定义实体，自动生成建表 SQL**
-
-#### 1. 定义实体类
-```java
-// ✅ 推荐：使用注解定义实体
-@Data
-@Table(value = "t_user", keyFields = "id")  // 表名和主键
-public class User {
-    
-    @Constraint(autoIncrement = true)
-    private Long id;  // 主键自增
-    
-    @Constraint(notNull = true, uniqueKey = "uk_email")
-    @Length(varcharSize = 100)
-    private String email;  // 非空 + 唯一索引 + 长度100
-    
-    @Constraint(notNull = true)
-    @Length(varcharSize = 50)
-    private String name;
-    
-    @Constraint(defaultValue = "0")
-    private Integer status;  // 默认值 0
-    
-    @Constraint(defaultValue = "NOW()", defaultValueIsFunction = true)
-    private Date createdAt;  // 默认当前时间
-    
-    @TableGenIgnore  // 忽略此字段，不生成列
-    private transient String tempField;
-}
-
-// 应用启动时自动建表
-CreateTable.createTable(pool, JDBCType.MySQL);
-
-// ❌ 避免：手写建表 SQL
-String sql = "CREATE TABLE t_user (id BIGINT AUTO_INCREMENT PRIMARY KEY, ...)";
-pool.query(sql).execute();  // 不要这样写！
-```
-
-#### 2. 支持的注解
-
-**@Table** - 表定义
-- `value` - 表名（默认类名转下划线）
-- `keyFields` - 主键字段名（默认 "id"）
-
-**@Constraint** - 字段约束
-- `notNull = true` - 非空约束
-- `uniqueKey = "uk_name"` - 唯一索引（相同名称的字段组成联合唯一索引）
-- `defaultValue = "value"` - 默认值
-- `defaultValueIsFunction = true` - 默认值是函数（如 NOW()）
-- `autoIncrement = true` - 自增（仅用于主键）
-
-**@Length** - 字段长度
-- `varcharSize = 255` - VARCHAR 长度（默认 255）
-- `decimalSize = {10, 2}` - DECIMAL 精度（默认 {22, 2}）
-
-**@Column** - 自定义列名
-- `name = "column_name"` - 指定数据库列名
-
-**@TableGenIgnore** - 忽略字段（不生成列）
-
-#### 3. 自动创建数据库
-```java
-// ✅ 推荐：自动创建数据库
-JsonObject dbConfig = new JsonObject()
-    .put("jdbcUrl", "jdbc:mysql://localhost:3306/mydb")
-    .put("username", "root")
-    .put("password", "password");
-
-CreateDatabase.createDatabase(dbConfig);
-
-// ❌ 避免：手动连接和执行 CREATE DATABASE
-```
-
-#### 4. 支持的数据库类型
-- `JDBCType.MySQL` - MySQL
-- `JDBCType.PostgreSQL` - PostgreSQL
-- `JDBCType.H2DB` - H2 数据库
-
-### Parser 模块
-- 支持自定义解析器（Java/Python/JavaScript）
-- Python 使用 GraalPy 执行
-- 需要考虑安全性和沙箱隔离
-- WebSocket 支持外部 Python 环境连接
-
-```java
-// Parser 接口实现示例
-public class CustomParser implements IParser {
-    @Override
-    public Future<ParseResult> parse(String url, Map<String, String> params) {
-        return Future.future(promise -> {
-            // 异步解析逻辑
-            promise.complete(result);
-        });
-    }
-}
-```
-
-## Maven 配置注意事项
-
-### 测试执行
-```bash
-# 默认打包跳过测试
-mvn clean package
-
-# 执行测试
-mvn test -Dmaven.test.skip=false
-mvn clean package -Dmaven.test.skip=false
-```
-
-### 模块化构建
-```bash
-# 构建特定模块
-mvn clean package -pl parser -am
-```
-
-## 重要约定
-
-### 1. 异步优先
-- 所有 I/O 操作必须异步
-- 使用 Vert.x Future/Promise API
-- 避免阻塞 Event Loop
-
-### 2. 资源管理
-```java
-// ✅ 推荐：使用 try-with-resources
-try (InputStream is = new FileInputStream(file)) {
-    // 使用资源
-}
-
-// 或者确保在 finally 中关闭
-HttpClient client = vertx.createHttpClient();
-// 使用后必须关闭
-client.close();
-```
-
-### 3. 配置外部化
-- 配置文件优先使用 JSON 格式
-- 敏感信息不要硬编码
-- 支持环境变量覆盖
-
-### 4. 错误处理
-- 使用 Future 的 recover/otherwise
-- 记录详细的错误日志
-- 向用户返回友好的错误信息
-
-## 性能考虑
-
-1. **使用连接池**: 数据库连接、HTTP 客户端
-2. **缓存策略**: 解析结果、静态资源
-3. **批量操作**: 避免 N+1 查询问题
-4. **异步非阻塞**: 充分利用 Vert.x 优势
-
-## 安全要求
-
-### Parser 模块安全
-- 执行自定义代码必须沙箱隔离
-- 限制资源访问（文件、网络）
-- 设置执行超时
-- 验证输入参数
-
-```java
-// ✅ 推荐：带安全检查的执行
-public Future<Result> executeUserCode(String code) {
-    // 验证代码
-    if (!SecurityValidator.isValid(code)) {
-        return Future.failedFuture("Invalid code");
-    }
-    
-    // 在沙箱中执行
-    return sandboxExecutor.execute(code, TIMEOUT);
-}
-```
-
-### 输入验证
-```java
-// ✅ 推荐：验证所有外部输入
-public Future<Result> parse(String url) {
-    if (StringUtils.isBlank(url) || !UrlValidator.isValid(url)) {
-        return Future.failedFuture("Invalid URL");
-    }
-    // 继续处理
-}
-```
-
-## 文档和注释
-
-### JavaDoc 注释
-```java
-/**
- * 解析网盘链接获取下载信息
- * 
- * @param url 网盘分享链接
- * @param params 额外参数（如密码）
- * @return Future<ParseResult> 解析结果
- */
-public Future<ParseResult> parse(String url, Map<String, String> params) {
-    // 实现
-}
-```
-
-### 复杂逻辑注释
-```java
-// 处理特殊情况：某些网盘需要二次验证
-// 参考文档：docs/parser-flow.md
-if (needsSecondaryVerification) {
-    // 实现二次验证逻辑
-}
-```
-
-## 常见模式
-
-### 链式异步调用
-```java
-return fetchMetadata(url)
-    .compose(meta -> validateMetadata(meta))
-    .compose(meta -> fetchDownloadUrl(meta))
-    .compose(downloadUrl -> generateResult(downloadUrl))
-    .recover(this::handleError);
-```
-
-### 事件处理
-```java
-vertx.eventBus().<JsonObject>consumer("parser.request", msg -> {
-    JsonObject body = msg.body();
-    parse(body.getString("url"))
-        .onSuccess(result -> msg.reply(JsonObject.mapFrom(result)))
-        .onFailure(err -> msg.fail(500, err.getMessage()));
-});
-```
-
-## 不应该做的事
-
-1. ❌ 在 Event Loop 线程中执行阻塞操作
-2. ❌ 使用 `System.out.println()` 而不是日志框架
-3. ❌ 硬编码配置值（端口、路径、密钥等）
-4. ❌ 忽略异常或使用空 catch 块
-5. ❌ 返回 null，应该使用 Optional 或 Future.failedFuture()
-6. ❌ 在生产代码中使用 `e.printStackTrace()`
-7. ❌ 直接操作 Thread 而不使用 Vert.x 的 executeBlocking
-8. ❌ 提交包含 `logs/` 目录的代码
-
-## 代码审查清单
-
-生成代码时请确保：
-- [ ] 使用 Lombok 注解简化代码
-- [ ] 异步操作使用 Vert.x Future
-- [ ] 添加了 @Slf4j 和适当的日志
-- [ ] 异常处理完整
-- [ ] 输入参数已验证
-- [ ] 资源正确释放
-- [ ] 添加了必要的 JavaDoc
-- [ ] 遵循项目包命名规范
-- [ ] 没有阻塞操作在 Event Loop 中
-- [ ] 测试用例覆盖主要场景
-
-## 参考资源
-
-- Vert.x 文档: https://vertx.io/docs/
-- 项目 Parser 文档: `parser/doc/`
-- 前端文档: `web-front/doc/`
-- 安全测试指南: `parser/doc/SECURITY_TESTING_GUIDE.md`

.github/workflows/build.yml

@@ -35,11 +35,11 @@ jobs:
         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
         restore-keys: ${{ runner.os }}-m2
         
-    - name: 安装 GraalPy pip 包
-      run: |
-        cd parser
-        chmod +x setup-graalpy-packages.sh
-        ./setup-graalpy-packages.sh
+    - name: 编译项目
+      run: ./mvnw clean compile
       
-    - name: 编译并打包项目
-      run: ./mvnw clean package -DskipTests
+#    - name: 运行测试
+#      run: ./mvnw test
+      
+    - name: 打包项目
+      run: ./mvnw package -DskipTests

.github/workflows/maven.yml

@@ -53,13 +53,6 @@ jobs:
     - name: Build Frontend
       run: cd web-front && yarn install && yarn run build
 
-    - name: Install GraalPy pip packages (for Python tags)
-      if: contains(github.ref, 'py')
-      run: |
-        cd parser
-        chmod +x setup-graalpy-packages.sh
-        ./setup-graalpy-packages.sh
-
     - name: Build with Maven
       run: mvn -B package -DskipTests --file pom.xml
 
@@ -95,15 +88,9 @@ jobs:
       run: |
         GIT_TAG=$(git tag --points-at HEAD | head -n 1)
         echo "tag=$GIT_TAG" >> $GITHUB_OUTPUT
-        # 检查是否为 Python 版本标签（以 py 结尾）
-        if [[ "$GIT_TAG" == *py ]]; then
-          echo "is_python=true" >> $GITHUB_OUTPUT
-        else
-          echo "is_python=false" >> $GITHUB_OUTPUT
-        fi
 
-    - name: Build and push Docker image (Standard)
-      if: github.event_name != 'pull_request' && steps.tag.outputs.is_python == 'false'
+    - name: Build and push Docker image
+      if: github.event_name != 'pull_request'
       uses: docker/build-push-action@v5
       with:
         context: .
@@ -112,13 +99,3 @@ jobs:
         tags: |
           ghcr.io/qaiu/netdisk-fast-download:${{ steps.tag.outputs.tag }}
           ghcr.io/qaiu/netdisk-fast-download:latest
-
-    - name: Build and push Docker image (Python)
-      if: github.event_name != 'pull_request' && steps.tag.outputs.is_python == 'true'
-      uses: docker/build-push-action@v5
-      with:
-        context: .
-        push: true
-        platforms: linux/amd64,linux/arm64,linux/arm/v7
-        tags: |
-          ghcr.io/qaiu/netdisk-fast-download:${{ steps.tag.outputs.tag }}

.gitignore

@@ -41,7 +41,9 @@ gradlew.bat
 unused.txt
 /web-service/src/main/generated/
 /db
+/netdisk-fast-download/
 /webroot/nfd-front/
+/netdisk-fast-download/webroot/nfd-front/
 package-lock.json
 
 # Maven generated files
@@ -81,6 +83,11 @@ yarn-error.log*
 *.ipr
 *.iws
 
-# GraalPy pip packages (local installation)
-parser/src/main/resources/graalpy-packages/
-**/graalpy-packages/
+# Build directories
+**/target/
+**/build/
+**/classes/
+**/out/
+**/${project.build.directory}/
+**/${project.basedir}/target/
+**/${basedir}/target/

.vscode/launch.json

@@ -1,77 +1,18 @@
 {
-    // 使用 IntelliSense 了解相关属性。 
-    // 悬停以查看现有属性的描述。
-    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
-        {
-            "type": "java",
-            "name": "PythonSecurityTestMain",
-            "request": "launch",
-            "mainClass": "cn.qaiu.parser.custompy.PythonSecurityTestMain",
-            "projectName": "parser"
-        },
         {
             "type": "java",
             "name": "Current File",
             "request": "launch",
             "mainClass": "${file}"
         },
-        {
-            "type": "java",
-            "name": "StringCase",
-            "request": "launch",
-            "mainClass": "cn.qaiu.vx.core.util.StringCase",
-            "projectName": "core"
-        },
-        {
-            "type": "java",
-            "name": "FCURLParser",
-            "request": "launch",
-            "mainClass": "cn.qaiu.parser.FCURLParser",
-            "projectName": "parser"
-        },
-        {
-            "type": "java",
-            "name": "QkTool",
-            "request": "launch",
-            "mainClass": "cn.qaiu.parser.impl.QkTool",
-            "projectName": "parser"
-        },
-        {
-            "type": "java",
-            "name": "WebClientExample",
-            "request": "launch",
-            "mainClass": "qaiu.web.test.WebClientExample",
-            "projectName": "parser"
-        },
         {
             "type": "java",
             "name": "AppMain",
             "request": "launch",
             "mainClass": "cn.qaiu.lz.AppMain",
             "projectName": "web-service"
-        },
-        {
-            "type": "java",
-            "name": "TestJs",
-            "request": "launch",
-            "mainClass": "cn.qaiu.web.test.TestJs",
-            "projectName": "web-service"
-        },
-        {
-            "type": "java",
-            "name": "TestOS",
-            "request": "launch",
-            "mainClass": "cn.qaiu.web.test.TestOS",
-            "projectName": "web-service"
-        },
-        {
-            "type": "java",
-            "name": "WebProxyExamples",
-            "request": "launch",
-            "mainClass": "cn.qaiu.web.test.WebProxyExamples",
-            "projectName": "web-service"
         }
     ]
 }

.vscode/settings.json

@@ -1,4 +1,5 @@
 {
     "java.compile.nullAnalysis.mode": "automatic",
-    "java.configuration.updateBuildConfiguration": "automatic"
+    "java.configuration.updateBuildConfiguration": "interactive",
+    "java.debug.settings.onBuildFailureProceed": true
 }

PLAYGROUND_ENHANCEMENT_CHANGELOG.md

@@ -1,338 +0,0 @@
-# 演练场增强功能 - 变更总结
-
-## 📅 实现日期
-2026年1月18日
-
-## 🎯 总体目标完成度
-✅ **100% 完成**
-
----
-
-## 📝 变更清单
-
-### 新增文件
-
-#### 1. `parser/src/main/resources/requests_guard.py` (467 行)
-- 完整的网络请求拦截猴子补丁模块
-- 支持 requests、urllib 等网络库
-- 包含详细的审计日志系统
-- 无任何外部依赖
-
-**关键类和函数**:
-- `GuardLogger` - 日志记录器
-- `_patch_requests()` - requests库补丁
-- `_patch_urllib()` - urllib库补丁
-- `_validate_url()` - URL验证逻辑
-- `_ip_in_nets()` - IP地址检查
-- `_hostname_resolves_to_private()` - DNS验证
-
-#### 2. `parser/src/main/java/cn/qaiu/parser/custompy/PyCodePreprocessor.java` (340 行)
-- Python代码动态预处理器
-- 自动检测和注入安全补丁
-- 生成预处理日志
-
-**关键类**:
-- `PyCodePreprocessor` - 主预处理器
-- `PyPreprocessResult` - 预处理结果
-- `NetworkLibraryDetection` - 网络库检测
-
-#### 3. `PLAYGROUND_ENHANCEMENT_IMPLEMENTATION.md` (550+ 行)
-- 完整的实现文档
-- 包含所有设计细节和代码示例
-
-#### 4. `PLAYGROUND_ENHANCEMENT_QUICK_REFERENCE.md` (300+ 行)
-- 快速参考指南
-- 用户使用指南
-- 常见问题解答
-
----
-
-### 修改的文件
-
-#### 1. `web-front/src/views/Playground.vue`
-
-**变更1: 文件导入UI** (~20 行)
-```vue
-<!-- 新增导入菜单项 -->
-<el-dropdown-item icon="Upload" @click="importFile">导入文件</el-dropdown-item>
-
-<!-- 新增隐藏文件输入 -->
-<input 
-  ref="fileImportInput"
-  type="file"
-  style="display: none"
-  @change="handleFileImport"
-  accept=".js,.py,.txt"
-/>
-```
-
-**变更2: 粘贴功能增强** (~60 行)
-```javascript
-// 改进了粘贴逻辑，支持多行、错误处理等
-const pasteCode = async () => { ... }
-```
-
-**变更3: 文件导入处理** (~45 行)
-```javascript
-const importFile = () => { ... }
-const handleFileImport = async (event) => { ... }
-```
-
-**变更4: 日志显示增强** (~15 行)
-```vue
-<!-- 支持显示 [JAVA]、[PYTHON]、[JS] 标签 -->
-<span v-if="log.source" class="console-source-tag" ...>
-  [{{ log.source === 'java' ? 'JAVA' : ... }}]
-</span>
-```
-
-**变更5: CSS样式补充** (~45 行)
-```css
-.console-java-source { ... }
-.console-python-source { ... }
-.console-source-java { ... }
-.console-source-python { ... }
-/* 亮色/暗黑主题支持 */
-```
-
-**总计**: 约 185 行代码变更
-
-#### 2. `parser/src/main/java/cn/qaiu/parser/custompy/PyPlaygroundExecutor.java`
-
-**变更1: executeParseAsync()** (~12 行)
-```java
-// 添加代码预处理
-PyCodePreprocessor.PyPreprocessResult preprocessResult = PyCodePreprocessor.preprocess(pyCode);
-playgroundLogger.infoJava(preprocessResult.getLogMessage());
-String codeToExecute = preprocessResult.getProcessedCode();
-```
-
-**变更2: executeParseFileListAsync()** (~8 行)
-```java
-// 同样的预处理逻辑
-```
-
-**变更3: executeParseByIdAsync()** (~8 行)
-```java
-// 同样的预处理逻辑
-```
-
-**总计**: 约 28 行代码变更
-
----
-
-## 🔄 集成流程
-
-### 前端流程
-```
-用户交互（导入/粘贴） → Playground.vue处理 → 本地存储 → 执行时发送到后端
-```
-
-### 后端流程
-```
-PlaygroundApi.test() → PyPlaygroundExecutor
-  ├─ 安全检查 (PyCodeSecurityChecker)
-  ├─ 代码预处理 (PyCodePreprocessor) ✨ 新增
-  │  ├─ 检测网络库导入
-  │  ├─ 加载requests_guard.py
-  │  └─ 注入补丁到代码
-  ├─ 执行增强代码
-  │ └─ 所有网络请求自动拦截
-  └─ 收集日志返回前端
-```
-
----
-
-## 📦 依赖关系
-
-### 新增Java类依赖
-```
-PyCodePreprocessor
-├── 依赖: 标准库 (io, nio, util, regex)
-├── 使用: LoggerFactory (SLF4J)
-└── 被调用: PyPlaygroundExecutor
-```
-
-### 新增Python模块依赖
-```
-requests_guard.py
-├── 依赖: socket (标准库)
-├── 依赖: urllib (标准库)
-├── 依赖: ipaddress (标准库)
-└── 无外部依赖 ✅
-```
-
----
-
-## 🧪 测试覆盖
-
-### 单元测试建议
-- [ ] PyCodePreprocessor 代码分析
-- [ ] PyCodePreprocessor 补丁注入
-- [ ] requests_guard.py IP检查
-- [ ] requests_guard.py 端口检查
-- [ ] requests_guard.py DNS验证
-
-### 集成测试建议
-- [ ] Python代码+requests包→执行→拦截
-- [ ] Python代码+urllib包→执行→拦截
-- [ ] 访问公网地址→通过
-- [ ] 访问本地地址→拦截
-- [ ] 访问私网地址→拦截
-
-### 前端测试建议
-- [ ] 导入.js/.py/.txt文件
-- [ ] 粘贴多行代码
-- [ ] 查看控制台日志（Java/Python/JS标签）
-- [ ] 移动端粘贴操作
-- [ ] 暗黑主题日志显示
-
----
-
-## 📊 代码统计
-
-| 文件 | 类型 | 行数 | 备注 |
-|------|------|------|------|
-| requests_guard.py | 新增 | 467 | Python补丁 |
-| PyCodePreprocessor.java | 新增 | 340 | Java预处理器 |
-| Playground.vue | 修改 | +185 | 前端增强 |
-| PyPlaygroundExecutor.java | 修改 | +28 | 集成预处理 |
-| 文档 | 新增 | 850+ | 实现+参考 |
-| **总计** | | **1870+** | |
-
----
-
-## ⚡ 性能影响
-
-### CPU 使用
-- 代码预处理: < 50ms (一次性)
-- 补丁加载: < 30ms (首次缓存)
-- 网络请求验证: < 5ms
-
-**总体影响**: 可忽略 ✅
-
-### 内存使用
-- requests_guard.py 模块: ~50KB
-- PyCodePreprocessor 类: ~20KB
-
-**总体影响**: 低 ✅
-
-### 网络延迟
-无额外网络开销 ✅
-
----
-
-## 🔐 安全改进
-
-### 防御范围
-- ✅ 本地地址访问 (127.0.0.0/8)
-- ✅ 私网地址访问 (10.0.0.0/8 等)
-- ✅ 危险端口访问 (22, 3306等)
-- ✅ DNS欺骗防御 (解析后验证)
-- ✅ 协议检查 (仅http/https)
-
-### 审计日志
-- ✅ 所有请求记录
-- ✅ 允许/拦截状态
-- ✅ 拦截原因
-- ✅ 时间戳
-- ✅ 源标签 (Java/Python)
-
----
-
-## 🚀 部署步骤
-
-1. **后端构建**
-   ```bash
-   cd parser
-   mvn clean package
-   ```
-
-2. **资源文件**
-   - requests_guard.py 自动包含在 JAR 中
-   - 路径: `parser/src/main/resources/requests_guard.py`
-
-3. **前端构建**
-   ```bash
-   cd web-front
-   npm run build
-   ```
-
-4. **验证**
-   - 启动服务
-   - 访问演练场
-   - 执行包含requests的Python代码
-   - 检查控制台日志
-
----
-
-## 📋 Checklist
-
-### 实现
-- [x] 文件导入功能
-- [x] 粘贴功能增强
-- [x] requests_guard.py 模块
-- [x] PyCodePreprocessor 类
-- [x] PyPlaygroundExecutor 集成
-- [x] 前端日志显示
-- [x] CSS样式支持
-
-### 文档
-- [x] 完整实现文档
-- [x] 快速参考指南
-- [x] 变更总结（本文档）
-- [x] 代码注释
-
-### 测试
-- [x] 代码语法检查 (无错误)
-- [x] 代码格式检查 (符合规范)
-- [ ] 单元测试 (建议补充)
-- [ ] 集成测试 (建议补充)
-- [ ] 浏览器兼容性 (已验证主流浏览器)
-
-### 生产准备
-- [x] 性能优化
-- [x] 错误处理
-- [x] 日志记录
-- [x] 安全审计
-- [x] 文档完善
-
----
-
-## 🎓 技术亮点
-
-1. **动态代码注入** - 在运行时修改代码执行环境，无需修改用户代码
-2. **猴子补丁模式** - 优雅地扩展第三方库功能
-3. **异步日志记录** - 不阻塞代码执行
-4. **多层安全防御** - IP检查、端口检查、DNS验证
-5. **用户体验优化** - 友好的错误提示和日志显示
-
----
-
-## 📞 支持信息
-
-### 文档
-- 完整实现: `PLAYGROUND_ENHANCEMENT_IMPLEMENTATION.md`
-- 快速参考: `PLAYGROUND_ENHANCEMENT_QUICK_REFERENCE.md`
-
-### 联系方式
-- GitHub Issues: [项目地址]/issues
-- 文档: 见上述文件
-
----
-
-## 🏆 总结
-
-本次增强为NetDisk Fast Download的演练场增加了：
-1. **用户友好的编辑功能** - 文件导入、增强粘贴
-2. **企业级安全功能** - 网络请求拦截、审计日志
-3. **完整的文档体系** - 实现文档、参考指南
-
-代码质量高、文档完善、性能优异、安全可靠。
-
-**状态**: ✅ 可立即投入生产
-
----
-
-*最后更新于 2026年1月18日*  
-*版本 v1.0 | 完成度 100%*

PLAYGROUND_ENHANCEMENT_IMPLEMENTATION.md

@@ -1,559 +0,0 @@
-# 演练场增强功能实现总结
-
-## 项目日期
-2026年1月18日
-
-## 功能概述
-本次实现为NetDisk Fast Download项目的演练场（Playground）增加了以下核心功能：
-
-### 1. 编辑器UI增强
-- **文件导入功能** - 支持直接导入本地JS/Python/TXT文件
-- **原生粘贴支持** - 增强粘贴操作，支持多行代码粘贴，优化移动端体验
-
-### 2. 网络请求安全拦截
-- **requests_guard猴子补丁** - 完整的请求拦截和审计日志系统
-- **Python代码预处理** - 在运行时自动检测并注入安全补丁
-- **实时日志反馈** - 演练场控制台显示安全拦截操作
-
----
-
-## 详细实现
-
-### 一、演练场编辑器UI增强 (web-front)
-
-#### 1.1 文件导入功能
-
-**位置**: `web-front/src/views/Playground.vue`
-
-**新增组件**:
-```vue
-<!-- 隐藏的文件导入input -->
-<input 
-  ref="fileImportInput"
-  type="file"
-  style="display: none"
-  @change="handleFileImport"
-  accept=".js,.py,.txt"
-/>
-```
-
-**新增菜单项**:
-```vue
-<el-dropdown-item icon="Upload" @click="importFile">导入文件</el-dropdown-item>
-```
-
-**实现的方法**:
-
-```javascript
-// 触发文件选择对话框
-const importFile = () => {
-  if (fileImportInput.value) {
-    fileImportInput.value.click();
-  }
-};
-
-// 处理文件导入
-const handleFileImport = async (event) => {
-  const file = event.target.files?.[0];
-  if (!file) return;
-
-  try {
-    const fileContent = await new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = (e) => resolve(e.target.result);
-      reader.onerror = () => reject(new Error('文件读取失败'));
-      reader.readAsText(file, 'UTF-8');
-    });
-
-    if (activeFile.value) {
-      activeFile.value.content = fileContent;
-      activeFile.value.modified = true;
-      activeFile.value.name = file.name;
-      
-      // 根据文件扩展名识别语言
-      const ext = file.name.split('.').pop().toLowerCase();
-      if (ext === 'py') {
-        activeFile.value.language = 'python';
-      } else if (ext === 'js' || ext === 'txt') {
-        activeFile.value.language = 'javascript';
-      }
-      
-      saveAllFilesToStorage();
-      ElMessage.success(`文件"${file.name}"已导入，大小：${(file.size / 1024).toFixed(2)}KB`);
-    }
-  } catch (error) {
-    ElMessage.error('导入失败: ' + error.message);
-  }
-
-  // 重置input以允许再次选择同一文件
-  if (fileImportInput.value) {
-    fileImportInput.value.value = '';
-  }
-};
-```
-
-**特点**:
-- 支持 `.js`, `.py`, `.txt` 文件格式
-- 自动识别文件语言并设置编辑器模式
-- 文件大小提示
-- 保存到LocalStorage
-
----
-
-#### 1.2 原生粘贴支持增强
-
-**位置**: `web-front/src/views/Playground.vue`
-
-**改进点**:
-
-1. **多行粘贴支持** - 正确处理多行代码粘贴
-2. **移动端优化** - 处理输入法逐行输入问题
-3. **错误处理** - 友好的权限和错误提示
-
-```javascript
-const pasteCode = async () => {
-  try {
-    const text = await navigator.clipboard.readText();
-    
-    if (!text) {
-      ElMessage.warning('剪贴板为空');
-      return;
-    }
-
-    if (editorRef.value && editorRef.value.getEditor) {
-      const editor = editorRef.value.getEditor();
-      if (editor) {
-        const model = editor.getModel();
-        if (!model) {
-          ElMessage.error('编辑器未就绪');
-          return;
-        }
-
-        // 获取当前选择范围，如果没有选择则使用光标位置
-        const selection = editor.getSelection();
-        const range = selection || new (window.monaco?.Range || editor.getModel().constructor.Range)(1, 1, 1, 1);
-
-        // 使用executeEdits执行粘贴操作，支持一次多行粘贴
-        const edits = [{
-          range: range,
-          text: text,
-          forceMoveMarkers: true
-        }];
-
-        editor.executeEdits('paste-command', edits, [(selection || range)]);
-        editor.focus();
-        
-        const lineCount = text.split('\n').length;
-        ElMessage.success(`已粘贴 ${lineCount} 行内容`);
-      }
-    } else {
-      ElMessage.error('编辑器未加载');
-    }
-  } catch (error) {
-    if (error.name === 'NotAllowedError') {
-      ElMessage.warning('粘贴权限被拒绝，请使用 Ctrl+V 快捷键');
-    } else {
-      console.error('粘贴失败:', error);
-      ElMessage.error('粘贴失败: ' + (error.message || '请使用 Ctrl+V'));
-    }
-  }
-};
-```
-
-**特点**:
-- 处理粘贴权限问题
-- 显示粘贴行数
-- 支持选区替换和光标位置插入
-
----
-
-### 二、网络请求安全拦截系统
-
-#### 2.1 requests_guard.py 猴子补丁模块
-
-**位置**: `parser/src/main/resources/requests_guard.py`
-
-**核心功能**:
-
-1. **IP地址验证**
-```python
-PRIVATE_NETS = [
-    "127.0.0.0/8",        # 本地回环
-    "10.0.0.0/8",         # A 类私网
-    "172.16.0.0/12",      # B 类私网
-    "192.168.0.0/16",     # C 类私网
-    "0.0.0.0/8",          # 0.x.x.x
-    "169.254.0.0/16",     # Link-local
-    "224.0.0.0/4",        # 多播地址
-    "240.0.0.0/4",        # 预留地址
-]
-```
-
-2. **危险端口检测**
-```python
-DANGEROUS_PORTS = [
-    22, 25, 53, 3306, 5432, 6379,  # 常见网络服务
-    8000, 8001, 8080, 8888,         # 开发服务器端口
-    27017,                           # MongoDB
-]
-```
-
-3. **请求拦截与审计日志**
-```
-[2026-01-18 10:15:30.123] [Guard-ALLOW] GET  https://example.com/api/data
-[2026-01-18 10:15:35.456] [Guard-BLOCK] POST https://127.0.0.1:8080/api - 本地地址
-[2026-01-18 10:15:40.789] [Guard-BLOCK] GET  https://192.168.1.10/api - 私网地址
-```
-
-4. **支持的网络库**
-- `requests` - 完整支持
-- `urllib` - urllib.request.urlopen 包装
-- 可扩展支持 httpx、aiohttp 等
-
-5. **安全检查点**
-- URL 格式验证
-- 协议检查（仅允许 http/https）
-- 本地地址检测（localhost, 127.0.0.1, ::1）
-- 私网地址检测（CIDR 检查）
-- 危险端口检测
-- DNS 解析结果验证
-
----
-
-#### 2.2 PyCodePreprocessor Java类
-
-**位置**: `parser/src/main/java/cn/qaiu/parser/custompy/PyCodePreprocessor.java`
-
-**核心职责**:
-
-1. **代码分析** - 检测代码中的网络请求库导入
-```java
-// 检测的导入模式
-IMPORT_REQUESTS  // import requests 或 from requests
-IMPORT_URLLIB    // import urllib 或 from urllib
-IMPORT_HTTPX     // import httpx 或 from httpx
-IMPORT_AIOHTTP   // import aiohttp 或 from aiohttp
-IMPORT_SOCKET    // import socket 或 from socket
-```
-
-2. **猴子补丁注入** - 在代码执行前动态注入补丁
-```
-原始代码：
-"""模块文档"""
-import requests
-
-def parse():
-    ...
-
-注入后的代码：
-"""模块文档"""
-
-# ===== 自动注入的网络请求安全补丁 (由 PyCodePreprocessor 生成) =====
-[requests_guard.py 完整内容]
-# ===== 安全补丁结束 =====
-
-import requests
-
-def parse():
-    ...
-```
-
-3. **日志生成** - 为演练场控制台生成预处理信息
-```
-✓ 网络请求安全拦截已启用 (检测到: requests, urllib) | 已动态注入 requests_guard 猴子补丁
-```
-
-**实现细节**:
-
-```java
-public static PyPreprocessResult preprocess(String originalCode) {
-    if (originalCode == null || originalCode.trim().isEmpty()) {
-        return new PyPreprocessResult(originalCode, false, null, "代码为空，无需预处理");
-    }
-    
-    // 检测网络请求库
-    NetworkLibraryDetection detection = detectNetworkLibraries(originalCode);
-    
-    if (detection.hasAnyNetworkLibrary()) {
-        // 加载猴子补丁代码
-        String patchCode = loadRequestsGuardPatch();
-        
-        if (patchCode != null && !patchCode.isEmpty()) {
-            // 在代码头部注入补丁
-            String preprocessedCode = injectPatch(originalCode, patchCode);
-            
-            String logMessage = String.format(
-                    "✓ 网络请求安全拦截已启用 (检测到: %s) | 已动态注入 requests_guard 猴子补丁",
-                    detection.getDetectedLibrariesAsString()
-            );
-            
-            return new PyPreprocessResult(
-                    preprocessedCode, 
-                    true, 
-                    detection.getDetectedLibraries(),
-                    logMessage
-            );
-        }
-    }
-    
-    return new PyPreprocessResult(originalCode, false, null, 
-            "ℹ 代码中未检测到网络请求库，不需要注入安全拦截补丁");
-}
-```
-
----
-
-#### 2.3 PyPlaygroundExecutor集成
-
-**位置**: `parser/src/main/java/cn/qaiu/parser/custompy/PyPlaygroundExecutor.java`
-
-**集成点**:
-
-在 `executeParseAsync()`、`executeParseFileListAsync()` 和 `executeParseByIdAsync()` 方法中添加代码预处理：
-
-```java
-// Python代码预处理 - 检测并注入猴子补丁
-PyCodePreprocessor.PyPreprocessResult preprocessResult = PyCodePreprocessor.preprocess(pyCode);
-playgroundLogger.infoJava(preprocessResult.getLogMessage());
-String codeToExecute = preprocessResult.getProcessedCode();
-
-// 然后执行预处理后的代码
-context.eval("python", codeToExecute);
-```
-
-**日志流程**:
-
-1. 预处理时生成日志信息
-2. 通过 `playgroundLogger.infoJava()` 添加到日志列表
-3. 日志包含在 API 响应中返回给前端
-4. 前端在演练场控制台中显示
-
----
-
-### 三、演练场控制台日志显示
-
-#### 3.1 前端日志显示增强
-
-**位置**: `web-front/src/views/Playground.vue`
-
-**日志来源标记**:
-
-```vue
-<span v-if="log.source" class="console-source-tag" :class="'console-source-' + (log.source || 'unknown')">
-  [{{ log.source === 'java' ? 'JAVA' : (log.source === 'JS' ? 'JS' : 'PYTHON') }}]
-</span>
-```
-
-**CSS样式分类**:
-
-```css
-/* JavaScript日志 - 绿色主题 */
-.console-js-source {
-  border-left-color: var(--el-color-success) !important;
-  background: var(--el-color-success-light-9) !important;
-}
-
-/* Java日志（包括预处理日志）- 橙色主题 */
-.console-java-source {
-  border-left-color: var(--el-color-warning) !important;
-  background: var(--el-color-warning-light-9) !important;
-}
-
-/* Python日志 - 蓝色主题 */
-.console-python-source {
-  border-left-color: var(--el-color-info) !important;
-  background: var(--el-color-info-light-9) !important;
-}
-
-/* 源标记样式 */
-.console-source-tag {
-  display: inline-block;
-  color: white;
-  font-size: 10px;
-  padding: 3px 8px;
-  border-radius: 10px;
-  margin-right: 8px;
-  font-weight: 600;
-  flex-shrink: 0;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
-}
-
-.console-source-java {
-  background: linear-gradient(135deg, var(--el-color-warning) 0%, var(--el-color-warning-light-3) 100%);
-  box-shadow: 0 2px 4px rgba(230, 162, 60, 0.3);
-}
-```
-
----
-
-## 演练场工作流程
-
-### 执行Python代码的完整流程:
-
-```
-用户在演练场提交代码
-    ↓
-前端发送 /v2/playground/test POST请求
-    ↓
-PlaygroundApi.test() 接收请求
-    ↓
-PyPlaygroundExecutor 创建实例
-    ↓
-executeParseAsync() 执行流程:
-    ├─ PyCodeSecurityChecker.check() - 安全检查
-    ├─ PyCodePreprocessor.preprocess() - 代码预处理
-    │  ├─ 检测导入的网络库
-    │  ├─ 加载 requests_guard.py
-    │  ├─ 注入补丁到代码头部
-    │  └─ 返回预处理日志："✓ 网络请求安全拦截已启用..."
-    ├─ playgroundLogger.infoJava() - 记录预处理日志
-    ├─ 执行预处理后的代码
-    │  └─ 代码运行时会自动应用猴子补丁
-    └─ 收集所有日志和执行结果
-    ↓
-API返回包含日志的响应
-    ↓
-前端接收并在演练场控制台显示所有日志:
-    ├─ [JAVA] 预处理日志（橙色，带[JAVA]标签）
-    ├─ [PYTHON] Python脚本中的 print/logger 日志（蓝色，带[PYTHON]标签）
-    └─ [Guard] 网络请求拦截日志（由补丁中的GuardLogger生成）
-```
-
----
-
-## 演练场控制台日志示例
-
-```
-[10:15:30] INFO  [JAVA] ✓ 网络请求安全拦截已启用 (检测到: requests, urllib) | 已动态注入 requests_guard 猴子补丁
-[10:15:31] DEBUG [JAVA] [Java] 安全检查通过
-[10:15:31] INFO  [JAVA] [Java] 开始执行parse方法
-[10:15:32] DEBUG [JAVA] [Java] 执行Python代码
-[10:15:33] INFO  [PYTHON] 正在解析链接: https://example.com/s/abc123
-[10:15:33] DEBUG [PYTHON] [Guard] 允许 GET https://example.com/s/abc123
-[10:15:34] INFO  [PYTHON] 获取到 5 个文件
-[10:15:35] INFO  [JAVA] [Java] 解析成功，返回结果: https://download.example.com/file.zip
-```
-
----
-
-## 安全特性
-
-### 1. 网络请求拦截范围
-- ✅ 拦截本地地址（127.0.0.1, localhost）
-- ✅ 拦截私网地址（10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 等）
-- ✅ 拦截危险端口（SSH, MySQL, Redis等）
-- ✅ DNS解析结果验证
-- ✅ 协议检查（仅允许http/https）
-
-### 2. 代码执行安全
-- ✅ 静态安全检查（在预处理前）
-- ✅ 动态补丁注入（不修改用户代码）
-- ✅ 审计日志记录（所有网络请求可追踪）
-- ✅ 超时控制（30秒执行超时）
-
-### 3. 扩展性
-- ✅ 支持添加更多网络库拦截
-- ✅ 支持自定义黑名单/白名单
-- ✅ 支持热更新补丁代码
-- ✅ 支持自定义审计日志处理
-
----
-
-## 技术栈
-
-### 前端 (Vue.js 3)
-- Monaco Editor - 代码编辑
-- Element Plus - UI组件
-- FileReader API - 文件导入
-- Clipboard API - 粘贴操作
-
-### 后端 (Java)
-- Vert.x 4.5.23 - 异步框架
-- GraalVM Polyglot - Python执行
-- SLF4J + Logback - 日志记录
-- 正则表达式 - 代码分析
-
-### Python
-- 标准库：socket、urllib
-- 无额外依赖 - 补丁模块独立运行
-
----
-
-## 文件清单
-
-### 新增文件
-1. `parser/src/main/resources/requests_guard.py` - 猴子补丁模块
-2. `parser/src/main/java/cn/qaiu/parser/custompy/PyCodePreprocessor.java` - 代码预处理器
-
-### 修改的文件
-1. `web-front/src/views/Playground.vue` - 编辑器UI和日志显示
-2. `parser/src/main/java/cn/qaiu/parser/custompy/PyPlaygroundExecutor.java` - 集成预处理器
-
----
-
-## 使用方式
-
-### 1. 导入文件
-点击 "更多操作" → "导入文件" → 选择本地.js/.py/.txt文件
-
-### 2. 粘贴代码
-- 使用 "粘贴" 按钮
-- 或直接 Ctrl+V/Cmd+V
-- 支持多行代码一次性粘贴
-
-### 3. 查看安全拦截日志
-执行包含 requests/urllib 的Python代码时：
-1. 演练场控制台自动显示"✓ 网络请求安全拦截已启用"
-2. 所有网络请求都会记录在日志中
-3. 被拦截的请求显示拦截原因
-
----
-
-## 性能考虑
-
-- **代码预处理** - 仅在需要时执行，时间复杂度 O(n)
-- **补丁加载** - 一次性从资源文件加载，缓存在内存
-- **日志记录** - 异步操作，不阻塞代码执行
-- **前端显示** - 虚拟列表（当日志过多时）
-
----
-
-## 测试建议
-
-### 功能测试
-1. ✅ 导入不同格式的文件
-2. ✅ 粘贴多行代码和特殊字符
-3. ✅ 执行包含 requests 的Python代码
-4. ✅ 验证网络请求拦截日志
-5. ✅ 测试移动端编辑体验
-
-### 安全测试
-1. ✅ 尝试访问 127.0.0.1 等本地地址
-2. ✅ 尝试访问私网地址
-3. ✅ 尝试连接危险端口
-4. ✅ 验证日志中显示拦截原因
-
----
-
-## 后续增强建议
-
-1. **集成更多网络库** - httpx, aiohttp, twisted 等
-2. **白名单支持** - 允许特定地址/域名访问
-3. **审计日志持久化** - 保存到文件/数据库
-4. **性能优化** - 缓存IP解析结果
-5. **UI优化** - 日志搜索、过滤、导出功能
-6. **告警机制** - 频繁访问被拦截地址时告警
-
----
-
-## 许可证
-遵循项目原有许可证
-
----
-
-## 贡献者
-GitHub Copilot
-
----
-
-*本文档最后更新于 2026年1月18日*

PLAYGROUND_ENHANCEMENT_QUICK_REFERENCE.md

@@ -1,237 +0,0 @@
-# 演练场增强功能 - 快速参考
-
-## 🎯 功能一览
-
-### 1️⃣ 编辑器增强
-| 功能 | 操作 | 快捷键 |
-|------|------|--------|
-| 导入文件 | 更多 → 导入文件 | - |
-| 粘贴代码 | 粘贴 按钮或 Ctrl+V | Ctrl+V |
-| 支持的格式 | .js, .py, .txt | - |
-
-### 2️⃣ 网络安全拦截
-| 拦截项 | 示例 | 日志级别 |
-|--------|------|---------|
-| 本地地址 | 127.0.0.1, localhost | BLOCK |
-| 私网地址 | 192.168.1.x, 10.0.0.x | BLOCK |
-| 危险端口 | 22, 3306, 6379 | BLOCK |
-| 正常请求 | https://example.com | ALLOW |
-
-### 3️⃣ 控制台日志
-```
-[时间] [级别] [来源] 日志消息
-
-来源标签：
-  [JAVA]   - 后端Java日志（补丁注入、执行过程）
-  [PYTHON] - 用户Python代码日志
-  [JS]     - JavaScript日志
-```
-
----
-
-## 📋 场景示例
-
-### 场景1：导入Python脚本并执行
-
-1. 点击"导入文件"→选择`parser.py`
-2. 编辑器自动识别为Python模式
-3. 设置测试参数（分享链接）
-4. 点击"运行"执行
-
-**预期日志输出**：
-```
-[10:15:30] INFO  [JAVA] ✓ 网络请求安全拦截已启用 (检测到: requests) | 已动态注入 requests_guard 猴子补丁
-[10:15:31] DEBUG [JAVA] 安全检查通过
-[10:15:32] DEBUG [JAVA] 执行Python代码
-[10:15:33] INFO  [PYTHON] 正在解析: https://example.com/s/abc
-[10:15:33] DEBUG [PYTHON] [Guard] 允许 GET https://example.com/s/abc
-[10:15:34] INFO  [JAVA] 解析成功
-```
-
-### 场景2：尝试访问本地地址（会被拦截）
-
-**Python代码**:
-```python
-import requests
-
-def parse(share_link_info, http_client, logger):
-    response = requests.get("http://127.0.0.1:8080/api")  # ❌ 会被拦截
-    return response.text
-```
-
-**日志输出**:
-```
-[10:20:15] INFO  [JAVA] ✓ 网络请求安全拦截已启用 (检测到: requests)
-[10:20:16] DEBUG [JAVA] 执行Python代码
-[10:20:17] ERROR [PYTHON] [Guard] 禁止访问本地地址：http://127.0.0.1:8080/api
-```
-
-### 场景3：粘贴多行代码
-
-1. 复制多行JavaScript代码
-2. 点击"粘贴"按钮
-3. 代码一次性粘贴到编辑器
-
-**提示信息**: `已粘贴 15 行内容`
-
----
-
-## 🔒 安全检查规则
-
-### 被拦截的地址
-```
-❌ 127.0.0.1           - 本地回环
-❌ localhost           - 本地主机
-❌ ::1                 - IPv6本地
-❌ 10.0.0.0/8          - 私网A类
-❌ 172.16.0.0/12       - 私网B类
-❌ 192.168.0.0/16      - 私网C类
-❌ 169.254.0.0/16      - Link-local
-```
-
-### 被拦截的端口（特殊检查）
-```
-22   - SSH
-25   - SMTP
-53   - DNS
-3306 - MySQL
-5432 - PostgreSQL
-6379 - Redis
-8080 - 常见开发端口
-```
-
-### 只允许
-```
-✅ http://example.com   - 公网HTTP
-✅ https://api.github.com - 公网HTTPS
-```
-
----
-
-## 🛠️ 技术细节
-
-### 猴子补丁的工作原理
-
-```
-Python代码执行流程：
-┌─────────────────────────────────────────────┐
-│ 1. PyCodePreprocessor 分析代码               │
-│    ↓                                         │
-│ 2. 检测到 import requests                    │
-│    ↓                                         │
-│ 3. 从资源加载 requests_guard.py              │
-│    ↓                                         │
-│ 4. 在代码头部注入补丁                        │
-│    ↓                                         │
-│ 5. 注入完成，记录日志                        │
-│    ↓                                         │
-│ 6. 执行增强后的代码                          │
-│    ↓                                         │
-│ 7. 所有requests调用都经过补丁检查            │
-│    ↓                                         │
-│ 8. 合法请求继续，违规请求被拦截             │
-└─────────────────────────────────────────────┘
-```
-
-### 代码注入示例
-
-**原始代码**:
-```python
-"""网盘解析器"""
-import requests
-
-def parse(share_link_info, http_client, logger):
-    response = requests.get(share_link_info.share_url)
-    return response.text
-```
-
-**注入后的代码**:
-```python
-"""网盘解析器"""
-
-# ===== 自动注入的网络请求安全补丁 (由 PyCodePreprocessor 生成) =====
-[requests_guard.py 的完整内容 - 约400行]
-# ===== 安全补丁结束 =====
-
-import requests  # ← 这时requests已经被补丁过了
-
-def parse(share_link_info, http_client, logger):
-    response = requests.get(share_link_info.share_url)
-    return response.text
-```
-
----
-
-## 📊 日志级别说明
-
-| 级别 | 含义 | 场景 |
-|------|------|------|
-| DEBUG | 调试信息 | 安全检查开始、执行步骤 |
-| INFO | 一般信息 | 执行成功、补丁注入、请求允许 |
-| WARN | 警告 | 可能的问题（一般不会出现） |
-| ERROR | 错误 | 请求被拦截、执行失败 |
-
----
-
-## ⚡ 性能指标
-
-- **文件导入**: < 100ms
-- **代码预处理**: < 50ms
-- **补丁加载**: < 30ms（首次缓存）
-- **网络请求验证**: < 5ms
-
----
-
-## 🐛 常见问题
-
-### Q1: 为什么我的requests请求被拦截了？
-
-**A**: 检查请求URL是否为：
-- 本地地址（127.0.0.1, localhost）
-- 私网地址（192.168.x.x, 10.x.x.x等）
-- 危险端口（22, 3306等）
-
-在控制台日志中会显示具体原因。
-
-### Q2: 粘贴时出现权限错误怎么办？
-
-**A**: 某些浏览器在某些情况下会限制clipboard权限。
-- 尝试使用 Ctrl+V 快捷键代替
-- 确保页面URL是HTTPS（部分浏览器要求）
-- 检查浏览器隐私设置中的剪贴板权限
-
-### Q3: 导入的Python文件无法找到parse函数报错？
-
-**A**: 确保：
-1. 文件中有 `def parse(...)` 函数定义
-2. 函数签名正确：`parse(share_link_info, http_client, logger)`
-3. 函数返回字符串类型的URL
-
-### Q4: 如何禁用网络请求拦截？
-
-**A**: 当前版本无法禁用，这是安全功能。
-- 如需特殊需求，请联系管理员
-
----
-
-## 📱 移动端支持
-
-- ✅ 文件导入在移动端正常工作
-- ✅ 粘贴操作优化了移动端输入法问题
-- ✅ 日志显示自动适应小屏幕
-- ⚠️ 建议在PC上进行复杂编辑操作
-
----
-
-## 📞 获取帮助
-
-遇到问题可以：
-1. 查看控制台日志（最详细的信息）
-2. 查看完整的实现文档：[PLAYGROUND_ENHANCEMENT_IMPLEMENTATION.md](./PLAYGROUND_ENHANCEMENT_IMPLEMENTATION.md)
-3. 联系技术支持
-
----
-
-**最后更新**: 2026年1月18日  
-**版本**: 1.0  
-**状态**: ✅ 生产就绪

README.md

@@ -1,43 +1,51 @@
-<p align="center">
-  <img src="https://github.com/user-attachments/assets/87401aae-b0b6-4ffb-bbeb-44756404d26f" alt="项目预览图" />
-</p>
-
+# 一款网盘分享链接云解析快速下载服务  
+QQ交流群：1017480890
 <p align="center">
 <a href="https://github.com/qaiu/netdisk-fast-download/actions/workflows/maven.yml"><img src="https://img.shields.io/github/actions/workflow/status/qaiu/netdisk-fast-download/maven.yml?branch=v0.1.9b8a&style=flat"></a>
 <a href="https://www.oracle.com/cn/java/technologies/downloads"><img src="https://img.shields.io/badge/jdk-%3E%3D17-blue"></a>
-<a href="https://vertx-china.github.io"><img src="https://img.shields.io/badge/vert.x-4.5.23-blue?style=flat"></a>
+<a href="https://vertx-china.github.io"><img src="https://img.shields.io/badge/vert.x-4.5.24-blue?style=flat"></a>
 <a href="https://raw.githubusercontent.com/qaiu/netdisk-fast-download/master/LICENSE"><img src="https://img.shields.io/github/license/qaiu/netdisk-fast-download?style=flat"></a>
 <a href="https://github.com/qaiu/netdisk-fast-download/releases/"><img src="https://img.shields.io/github/v/release/qaiu/netdisk-fast-download?style=flat"></a>
+<a href="https://atomgit.com/QAIU/netdisk-fast-download"><img src="https://atomgit.com/QAIU/netdisk-fast-download/star/badge.svg" alt="AtomGit"></a>
+<a href="https://oosmetrics.com/repo/qaiu/netdisk-fast-download"><img src="https://api.oosmetrics.com/api/v1/badge/achievement/826aa27a-6e59-4de5-b7fa-cd189f484035.svg"></a>
+<p align="center">
+  <a href="https://trendshift.io/repositories/12101" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12101" alt="qaiu%2Fnetdisk-fast-download | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </p>
 
 
+![alt text](web-front/img/image.png)
 
 
-# netdisk-fast-download 网盘分享链接云解析服务  
-QQ群：1017480890
+## 国内镜像
 
-> **📌 分支说明：** 
-> - 本分支 (`feature/graalpy-parser`) 为 **Python 解析器支持版本**，包含 GraalPy 环境
-> - 如需标准版本（更小的镜像体积），请访问 [main 分支](https://github.com/qaiu/netdisk-fast-download/tree/main)
-> - Docker 镜像：Python 版本使用 py 标签（如 `v0.1.9b19py`），标准版本使用 `latest` 标签
+本项目同步托管于 **AtomGit**，国内访问更流畅：👉 [https://atomgit.com/QAIU/netdisk-fast-download](https://atomgit.com/QAIU/netdisk-fast-download)
+
+
+## 介绍
+> netdisk-fast-download网盘直链解析可以把云盘分享链接转为直链，可广泛应用于各类下载站，资源站，个人博客，图床，APP下载更新，视频点播等领域。支持市面各大主流云盘的文件分享以及文件夹分享链接，已支持蓝奏云/蓝奏云优享/移动云云空间/小飞机盘/亿方云/123云盘/Cloudreve等，支持加密分享，以及部分网盘文件夹分享。  
+
+[官方文档](https://nfd-parser.github.io/)  
+[API接入](https://nfdparser.apifox.cn/)  
+[公益解析，lz站](https://lz.qaiu.top)  
+[公益解析，lz0站](https://lz0.qaiu.top)  
+[专业版](https://189.qaiu.top)  
   
-netdisk-fast-download网盘直链云解析(nfd云解析)能把网盘分享下载链接转化为直链，支持多款云盘，已支持蓝奏云/蓝奏云优享/奶牛快传/移动云云空间/小飞机盘/亿方云/123云盘/Cloudreve等，支持加密分享，以及部分网盘文件夹分享。  
 
 ## 快速开始
 命令行下载分享文件：  
 ```shell
-curl -LOJ "https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/nQOaNRPW&pwd=1234"  
+curl -LOJ "https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/Tk1F2kGQ&pwd=1234"  
 ```
 或者使用wget:  
 ```shell
-wget -O bilibili.mp4 "https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/nQOaNRPW&pwd=1234"
+wget -O bilibili.mp4 "https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/Tk1F2kGQ&pwd=1234"
 ```
-或者使用浏览器[直接访问](https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.top%2Fparser%3Furl%3Dhttps%3A%2F%2Fshare.feijipan.com%2Fs%2FnQOaNRPW&name=bilibili.mp4&ext=mp4):
+或者使用浏览器[直接访问](https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.top%2Fparser%3Furl%3Dhttps%3A%2F%2Fshare.feijipan.com%2Fs%2FTk1F2kGQ&name=bilibili.mp4&ext=mp4):
 ```
 ### 调用演示站下载：
-https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/nQOaNRPW&pwd=1234  
+https://lz.qaiu.top/parser?url=https://share.feijipan.com/s/Tk1F2kGQ&pwd=1234  
 ### 调用演示站预览：
-https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.top%2Fparser%3Furl%3Dhttps%3A%2F%2Fshare.feijipan.com%2Fs%2FnQOaNRPW&name=bilibili.mp4&ext=mp4  
+https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.top%2Fparser%3Furl%3Dhttps%3A%2F%2Fshare.feijipan.com%2Fs%2FTk1F2kGQ&name=bilibili.mp4&ext=mp4  
 
 ```
 
@@ -45,42 +53,14 @@ https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.
 
 **JavaScript解析器文档：** [JavaScript解析器开发指南](parser/doc/JAVASCRIPT_PARSER_GUIDE.md) | [自定义解析器扩展指南](parser/doc/CUSTOM_PARSER_GUIDE.md) | [快速开始](parser/doc/CUSTOM_PARSER_QUICKSTART.md)
 
-**Python解析器文档：** [Python解析器开发指南](parser/doc/PYTHON_PARSER_GUIDE.md) | [Playground测试报告](parser/doc/PYTHON_PLAYGROUND_TEST_REPORT.md) | [pylsp WebSocket集成](parser/doc/PYLSP_WEBSOCKET_GUIDE.md)
+**Playground功能：** [JS解析器演练场密码保护说明](web-service/doc/PLAYGROUND_PASSWORD_PROTECTION.md)
 
-## 演练场（Playground）
 
-在线编写、测试和发布解析器脚本，支持 JavaScript 和 Python 两种语言。
-
-### 快速开始
-- **[演练场使用指南](web-service/doc/PLAYGROUND_GUIDE.md)** - 完整的使用教程和最佳实践
-- **[5分钟快速上手](parser/doc/CUSTOM_PARSER_QUICKSTART.md)** - 快速集成指南
-
-### 开发文档
-- **JavaScript解析器**: [开发指南](parser/doc/JAVASCRIPT_PARSER_GUIDE.md) | [自定义扩展](parser/doc/CUSTOM_PARSER_GUIDE.md)
-- **Python解析器**: [开发指南](parser/doc/PYTHON_PARSER_GUIDE.md) | [Python LSP连接](parser/doc/PYLSP_WEBSOCKET_GUIDE.md)
-
-### 配置和安全
-- **[密码保护配置](web-service/doc/PLAYGROUND_PASSWORD_PROTECTION.md)** - 访问控制和安全设置
-- **[界面功能说明](web-front/doc/PLAYGROUND_UI_UPGRADE.md)** - IDE功能和快捷键
-
-### 测试报告
-- **[Python演练场测试报告](parser/doc/PYTHON_PLAYGROUND_TEST_REPORT.md)** - 功能验证和测试覆盖
-
-### 在线体验
-访问演练场页面：`http://your_host/playground`（需要密码或配置公开访问）
-
-## 预览地址  
-[预览地址1](https://lz.qaiu.top)  
-[预览地址2](https://lz0.qaiu.top)  
-[移动/联通/天翼云盘大文件试用版](https://189.qaiu.top)  
-
-main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/netdisk-fast-download/tree/main-jdk11)  
-**0.1.8及以上版本json接口格式有调整 参考json返回数据格式示例**  
-**小飞机解析有IP限制，多数云服务商的大陆IP会被拦截（可以自行配置代理），和本程序无关**  
-**注意: 请不要过度依赖lz.qaiu.top预览地址服务，建议本地搭建或者云服务器自行搭建。解析次数过多IP会被部分网盘厂商限制，不推荐做公共解析。**  
+**注意⚠️小飞机解析有IP限制，多数云服务商的大陆IP会被拦截（可以自行配置代理），和本程序无关**  
+**注意⚠️收到很多用户反馈，小飞机近期封号频繁，请尽可能选择其他网盘分享**  
+**注意⚠️请不要过度依赖 lz.qaiu.top，建议本地搭建或者云服务器自行搭建。请求量过多的话服务器可能会被云盘厂商限制，遇到解析失败的分享链接不要着急提issues，请先检查分享是否有效。**
 
 ## 网盘支持情况:
-> 20230905 奶牛云直链做了防盗链，需加入请求头：Referer: https://cowtransfer.com/  
 > 20230824 123云盘解析大文件(>100MB)失效，需要登录  
 > 20230722 UC网盘解析失效，需要登录  
 
@@ -88,13 +68,11 @@ main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/
 
 - [蓝奏云-lz](https://pc.woozooo.com/)
 - [蓝奏云优享-iz](https://www.ilanzou.com/)
-- [奶牛快传-cow](https://cowtransfer.com/)
 - [移动云云空间-ec](https://www.ecpan.cn/web)
 - [小飞机网盘-fj](https://www.feijipan.com/)
 - [亿方云-fc](https://www.fangcloud.com/)
 - [123云盘-ye](https://www.123pan.com/)
 - ~[115网盘(失效)-p115](https://115.com/)~
-- ~[118网盘(已停服)-p118](https://www.118pan.com/)~
 - [文叔叔-ws](https://www.wenshushu.cn/)
 - [联想乐云-le](https://lecloud.lenovo.com/)
 - [QQ邮箱云盘-qqw](https://mail.qq.com/)
@@ -107,21 +85,19 @@ main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/
 - [Cloudreve自建网盘-ce](https://github.com/cloudreve/Cloudreve)
 - ~[微雨云存储-pvvy](https://www.vyuyun.com/)~
 - [超星云盘(需要referer: https://pan-yz.chaoxing.com)-pcx](https://pan-yz.chaoxing.com)
+- [飞书云盘-fs](https://www.feishu.cn/)
 - [WPS云文档-pwps](https://www.kdocs.cn/)
 - [汽水音乐-qishui_music](https://music.douyin.com/qishui/)
 - [咪咕音乐-migu](https://music.migu.cn/)
-- [一刻相册-baidu_photo](https://photo.baidu.com/)
 - Google云盘-pgd
 - Onedrive-pod
 - Dropbox-pdp
 - iCloud-pic
-### 仅专属版提供
-- [移动云盘-p139](https://yun.139.com/)
-- [联通云盘-pwo](https://pan.wo.cn/)
-- [天翼云盘-p189](https://cloud.189.cn/)
 
 ## API接口
 
+[api接口文档](https://nfdparser.apifox.cn/)
+  
 ### 服务端口
 - **6400**: API 服务端口（建议使用 Nginx 代理）
 - **6401**: 内置 Web 解析工具（个人使用可直接开放此端口）
@@ -165,6 +141,56 @@ GET /json/getFileList?url={分享链接}&pwd={密码}
 - `{网盘标识}` 参考支持的网盘列表
 - `your_host` 替换为您的域名或 IP
 
+### 认证参数（v0.2.1+）
+[可以使用在线认证参数加密](https://qaiu.top/nfd-auth.html)
+部分网盘（如夸克、UC）需要登录后的 Cookie 才能解析和下载。可通过 `auth` 参数传递认证信息：
+
+**参数格式**：`auth` 参数值为 AES 加密后的 JSON 字符串，经过 Base64 编码和 URL 编码
+
+**加密方式**：
+- 算法：AES/ECB/PKCS5Padding
+- 密钥：`nfd_auth_key2026`（16字节）
+- 流程：JSON → AES加密 → Base64 → URL编码
+
+**JSON 结构**：
+```json
+{
+  "authType": "cookie",        // 认证类型: cookie/accesstoken/authorization/password/custom
+  "token": "your_cookie_here", // Cookie 或 Token 内容
+  "username": "",              // 用户名（password 类型时使用）
+  "password": "",              // 密码（password 类型时使用）
+  "ext1": "",                  // 扩展字段1（custom 类型时使用）
+  "ext2": ""                   // 扩展字段2（custom 类型时使用）
+}
+```
+
+**网盘认证要求**：
+| 网盘 | 认证要求 | 说明 |
+|------|---------|------|
+| 夸克网盘(QK) | **必须** | 必须配置 Cookie 才能解析 |
+| UC网盘(UC) | **必须** | 必须配置 Cookie 才能解析 |
+| 小飞机网盘(FJ) | 可选 | 大文件（>100MB）需要认证 |
+| 蓝奏优享(IZ) | 可选 | 大文件需要认证 |
+
+**使用示例**：
+```
+GET /parser?url={分享链接}&pwd={密码}&auth={加密后的认证参数}
+```
+
+> 💡 提示：Web 界面已内置认证配置功能，可自动处理加密过程，无需手动构造参数。
+> [可以使用在线认证参数加密](https://qaiu.top/nfd-auth.html)
+
+#### 密钥作用说明
+
+- `server.authEncryptKey`
+  - 作用：用于 `auth` 参数的 AES 加解密
+  - 要求：16位（AES-128）
+
+- `server.donatedAccountFailureTokenSignKey`
+  - 作用：用于“捐赠账号失败计数 token”的 HMAC 签名/验签
+  - 目的：防止客户端伪造失败计数请求
+  - 建议：使用高强度随机字符串，且不要与 `authEncryptKey` 相同
+
 ### 特殊说明
 
 - 移动云云空间的 `分享key` 取分享链接中的 `data` 参数值
@@ -298,15 +324,15 @@ json返回数据格式示例:
 | 网盘名称        | 免登陆下载分享 | 加密分享     | 初始网盘空间    | 单文件大小限制         |
 |-------------|---------|----------|-----------|-----------------|
 | 蓝奏云         | √       | √        | 不限空间      | 100M            | 
-| 奶牛快传        | √       | X        | 10G       | 不限大小            | 
 | 移动云云空间(个人版) | √       | √(密码可忽略) | 5G(个人)    | 不限大小            |
-| 小飞机网盘       | √       | √(密码可忽略) | 10G       | 不限大小            | 
-| 360亿方云      | √       | √(密码可忽略) | 100G(须实名) | 不限大小            | 
+| 小飞机网盘       | √       | √        | 10G       | 不限大小            | 
+| 360亿方云      | √       | √        | 100G(须实名) | 不限大小            | 
 | 123云盘       | √       | √        | 2T        | 100G（>100M需要登录） | 
 | 文叔叔         | √       | √        | 10G       | 5GB             | 
 | WPS云文档      | √       | X        | 5G(免费)   | 10M(免费)/2G(会员)  |
 | 夸克网盘        | x       | √        | 10G       | 不限大小            | 
 | UC网盘        | x       | √        | 10G       | 不限大小            | 
+| 飞书云盘        | √       | X        | 15G       | 不限大小            |
 
 # 打包部署
 
@@ -318,51 +344,13 @@ json返回数据格式示例:
 
 ## 开发和打包
 
-### 环境要求
-- JDK 17+
-- Maven 3.x
-- Python 3.x（可选，仅当需要 Playground 代码智能提示功能时）
-
-### 本地构建步骤
-
-#### 1. Maven 打包
-
 ```shell
-# 清理并打包（跳过测试）
-mvn clean package -DskipTests
+# 环境要求: Jdk17 + maven;
+mvn clean
+mvn package -DskipTests
 
-# 如果遇到代理问题，可以禁用代理
-mvn clean package -DskipTests -Dhttp.proxyHost= -Dhttps.proxyHost=
 ```
-
-> **说明：** 
-> - Maven 构建时会自动安装 **requests** 等核心 Python 包（由 graalpy-maven-plugin 处理）
-> - 打包好的文件位于 `web-service/target/netdisk-fast-download-bin.zip`
-
-#### 2. （可选）安装 Python LSP 服务器
-
-如果需要使用 **Playground 代码智能提示功能**，需要额外安装 python-lsp-server：
-
-```shell
-# 进入 parser 目录
-cd parser
-
-# 运行 pip 包安装脚本
-chmod +x setup-graalpy-packages.sh
-./setup-graalpy-packages.sh
-
-# 返回项目根目录
-cd ..
-```
-
-该脚本会将以下包安装到 `parser/src/main/resources/graalpy-packages/`：
-- **python-lsp-server** 及其依赖（jedi, python-lsp-jsonrpc, pluggy）- Python LSP 服务器（代码智能提示）
-- **pylsp 可选功能**（pyflakes, pycodestyle, autopep8, rope, yapf）- 代码检查和格式化
-
-> **注意：** 
-> - 这些包需要用系统 pip 安装，因为 python-lsp-server 依赖 ujson（需编译 C 扩展）
-> - 安装后的包会被打包进 jar 文件，不会被 `mvn clean` 清理
-> - 如果不需要 Playground 的代码智能提示功能，可以跳过此步骤
+打包好的文件位于 web-service/target/netdisk-fast-download-bin.zip
 
 ## 🚀 快速部署
 
@@ -370,82 +358,7 @@ cd ..
 
 ## Linux服务部署
 
-### Docker 部署
-
-> **注意：** 本分支（feature/graalpy-parser）包含 Python 解析器支持（GraalPy），镜像体积较大。
-> 如果不需要 Python 解析器功能，建议使用 main 分支的标准版本。
-
-#### Python 版本特性
-- ✅ 支持 Python 自定义解析器（基于 GraalPy）
-- ✅ 内置 Python 语言服务器（pylsp）支持代码补全
-- ✅ 支持外部 Python 环境通过 WebSocket 连接
-- ⚠️ 镜像体积较大（约增加 200MB）
-
-#### 海外服务器Docker部署（Python版）
-
-> **注意：** 请根据 [Releases](https://github.com/qaiu/netdisk-fast-download/releases) 页面使用最新的 py 标签版本
-
-```shell
-# 创建目录
-mkdir -p netdisk-fast-download
-cd netdisk-fast-download
-
-# 拉取镜像（使用 py 标签，请替换为最新版本号）
-docker pull ghcr.io/qaiu/netdisk-fast-download:v0.1.9b19py
-
-# 复制配置文件（或下载仓库web-service\src\main\resources）
-docker create --name netdisk-fast-download ghcr.io/qaiu/netdisk-fast-download:v0.1.9b19py
-docker cp netdisk-fast-download:/app/resources ./resources
-docker rm netdisk-fast-download
-
-# 启动容器
-docker run -d -it --name netdisk-fast-download -p 6401:6401 --restart unless-stopped -e TZ=Asia/Shanghai -v ./resources:/app/resources -v ./db:/app/db -v ./logs:/app/logs ghcr.io/qaiu/netdisk-fast-download:v0.1.9b19py
-
-# 反代6401端口
-
-# 升级容器（请手动指定版本号）
-# 注意：Python 版本不会更新 latest 标签，需要手动指定版本
-docker pull ghcr.io/qaiu/netdisk-fast-download:v0.1.9b19py
-docker stop netdisk-fast-download
-docker rm netdisk-fast-download
-docker run -d -it --name netdisk-fast-download -p 6401:6401 --restart unless-stopped -e TZ=Asia/Shanghai -v ./resources:/app/resources -v ./db:/app/db -v ./logs:/app/logs ghcr.io/qaiu/netdisk-fast-download:v0.1.9b19py
-```
-
-#### 国内Docker部署（Python版）
-
-> **注意：** 请根据 [Releases](https://github.com/qaiu/netdisk-fast-download/releases) 页面使用最新的 py 标签版本
-
-```shell
-# 创建目录
-mkdir -p netdisk-fast-download
-cd netdisk-fast-download
-
-# 拉取镜像（使用 py 标签，请替换为最新版本号）
-docker pull ghcr.nju.edu.cn/qaiu/netdisk-fast-download:v0.1.9b19py
-
-# 复制配置文件（或下载仓库web-service\src\main\resources）
-docker create --name netdisk-fast-download ghcr.nju.edu.cn/qaiu/netdisk-fast-download:v0.1.9b19py
-docker cp netdisk-fast-download:/app/resources ./resources
-docker rm netdisk-fast-download
-
-# 启动容器
-docker run -d -it --name netdisk-fast-download -p 6401:6401 --restart unless-stopped -e TZ=Asia/Shanghai -v ./resources:/app/resources -v ./db:/app/db -v ./logs:/app/logs ghcr.nju.edu.cn/qaiu/netdisk-fast-download:v0.1.9b19py
-
-# 反代6401端口
-
-# 升级容器（请手动指定版本号）
-# 注意：Python 版本不会更新 latest 标签，需要手动指定版本
-docker pull ghcr.nju.edu.cn/qaiu/netdisk-fast-download:v0.1.9b19py
-docker stop netdisk-fast-download
-docker rm netdisk-fast-download
-docker run -d -it --name netdisk-fast-download -p 6401:6401 --restart unless-stopped -e TZ=Asia/Shanghai -v ./resources:/app/resources -v ./db:/app/db -v ./logs:/app/logs ghcr.nju.edu.cn/qaiu/netdisk-fast-download:v0.1.9b19py
-```
-
----
-
-### Docker 部署（标准版 - Main分支）
-
-如果不需要 Python 解析器功能，建议使用标准版本：
+### Docker 部署（Main分支）
 
 #### 海外服务器Docker部署
 ```shell
@@ -572,23 +485,6 @@ auths:
 
 **注意：** 目前仅支持 123（ye）的认证配置。
 
-## 开发计划
-### v0.1.8~v0.1.9 ✓
-- API添加文件信息(专属版/开源版)
-- 目录解析(专属版/开源版)
-- 文件预览功能(专属版/开源版)
-- 文件夹预览功能(开源版)
-- 友好的错误提示和一键反馈功能(开源版)
-- 带cookie/token/username/pwd参数解析大文件(专属版)
-### v0.2.x
-- web后台管理--认证配置/分享链接管理(开源版/专属版)
-- 123/小飞机/蓝奏优享等大文件解析(开源版)
-- 直链分享(开源版/专属版)
-- aria2/idm+/curl/wget链接生成(开源版/专属版)
-- IP限流配置(开源版/专属版)
-- refere防盗链，API鉴权防盗链(专属版)
-- 123/小飞机/蓝奏优享/蓝奏文件夹解析API，天翼云盘/移动云盘文件夹解析API(专属版)
-- 用户管理面板--营销推广系统(专属版)
 
 **技术栈:**
 Jdk17+Vert.x4
@@ -613,20 +509,6 @@ Core模块集成Vert.x实现类似spring的注解式路由API
 </p>
 
 
-### 关于赞助定制专属版
-1. 专属版提供对小飞机,蓝奏优享大文件解析的支持, 提供天翼云盘/移动云盘/联通云盘的解析支持。  
-2. 可提供托管服务：包含部署服务和云服务器环境。  
-3. 可提供功能定制开发。  
-您可能需要提供一定的资金赞助支持定制专属版， 请添加以下任意一个联系方式详谈赞助模式:  
-<p>qq: 197575894</p>
-<p>wechat: imcoding_</p>
-
-<!--
-![image](https://github.com/qaiu/netdisk-fast-download/assets/29825328/54276aee-cc3f-4ebd-8973-2e15f6295819)
-
-[手机端支付宝打赏跳转链接](https://qr.alipay.com/fkx01882dnoxxtjenhlxt53)
--->
-
 
 
 

core-database/pom.xml

@@ -68,20 +68,6 @@
             <version>42.7.3</version>
         </dependency>
 
-        <!-- 测试依赖 -->
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.38</version>
-            <scope>test</scope>
-        </dependency>
-
     </dependencies>
 
 </project>

core-database/src/main/java/cn/qaiu/db/ddl/CreateTable.java

@@ -303,7 +303,7 @@ public class CreateTable {
             return promise.future();
         }
 
-        List<Future<Object>> createFutures = new ArrayList<>();
+        List<Future<Object>> futures = new ArrayList<>();
 
         for (Class<?> clazz : tableClasses) {
             List<String> sqlList = getCreateTableSQL(clazz, type);
@@ -312,41 +312,23 @@ public class CreateTable {
             for (String sql : sqlList) {
                 try {
                     pool.query(sql).execute().toCompletionStage().toCompletableFuture().join();
-                    createFutures.add(Future.succeededFuture());
+                    futures.add(Future.succeededFuture());
                     LOGGER.debug("Executed SQL:\n{}", sql);
                 } catch (Exception e) {
                     String message = e.getMessage();
                     if (message != null && message.contains("Duplicate key name")) {
                         LOGGER.warn("Ignoring duplicate key error: {}", message);
-                        createFutures.add(Future.succeededFuture());
+                        futures.add(Future.succeededFuture());
                     } else {
                         LOGGER.error("SQL Error: {}\nSQL: {}", message, sql);
-                        createFutures.add(Future.failedFuture(e));
+                        futures.add(Future.failedFuture(e));
                         throw new RuntimeException(e); // Stop execution for other exceptions
                     }
                 }
             }
         }
 
-        // 创建表完成后，执行表结构迁移检查
-        Future.all(createFutures)
-            .compose(v -> {
-                LOGGER.info("开始检查表结构变更...");
-                List<Future<Void>> migrationFutures = new ArrayList<>();
-                for (Class<?> clazz : tableClasses) {
-                    migrationFutures.add(SchemaMigration.migrateTable(pool, clazz, type));
-                }
-                return Future.all(migrationFutures).mapEmpty();
-            })
-            .onSuccess(v -> {
-                LOGGER.info("表结构检查和变更完成");
-                promise.complete();
-            })
-            .onFailure(err -> {
-                LOGGER.error("表结构变更失败", err);
-                promise.fail(err);
-            });
-
+        Future.all(futures).onSuccess(r -> promise.complete()).onFailure(promise::fail);
         return promise.future();
     }
 

core-database/src/main/java/cn/qaiu/db/ddl/NewField.java

@@ -1,44 +0,0 @@
-package cn.qaiu.db.ddl;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 标识新增字段，用于数据库表结构迁移
- * 只有带此注解的字段才会被 SchemaMigration 检查和添加
- * 
- * <p>使用场景：</p>
- * <ul>
- *   <li>在现有实体类中添加新字段时，使用此注解标记</li>
- *   <li>应用启动时会自动检测并添加到数据库表中</li>
- *   <li>添加成功后可以移除此注解，避免重复检查</li>
- * </ul>
- * 
- * <p>示例：</p>
- * <pre>{@code
- * @Data
- * @Table("users")
- * public class User {
- *     private Long id;
- *     private String name;
- *     
- *     @NewField  // 标记为新增字段
- *     @Length(varcharSize = 32)
- *     @Constraint(defaultValue = "active")
- *     private String status;
- * }
- * }</pre>
- *
- * @author <a href="https://qaiu.top">QAIU</a>
- */
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NewField {
-    
-    /**
-     * 字段描述（可选）
-     */
-    String value() default "";
-}

core-database/src/main/java/cn/qaiu/db/ddl/SchemaMigration.java

@@ -1,294 +0,0 @@
-package cn.qaiu.db.ddl;
-
-import cn.qaiu.db.pool.JDBCType;
-import io.vertx.codegen.format.Case;
-import io.vertx.codegen.format.LowerCamelCase;
-import io.vertx.codegen.format.SnakeCase;
-import io.vertx.core.Future;
-import io.vertx.core.Promise;
-import io.vertx.sqlclient.Pool;
-import io.vertx.sqlclient.templates.annotations.Column;
-import io.vertx.sqlclient.templates.annotations.RowMapped;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.reflect.Field;
-import java.util.*;
-
-/**
- * 数据库表结构变更处理器
- * 用于在应用启动时自动检测并添加缺失的字段
- *
- * @author <a href="https://qaiu.top">QAIU</a>
- */
-public class SchemaMigration {
-
-    private static final Logger log = LoggerFactory.getLogger(SchemaMigration.class);
-
-    /**
-     * 检查并迁移表结构
-     * 只处理带有 @NewField 注解的字段，避免检查所有字段导致的重复错误
-     *
-     * @param pool 数据库连接池
-     * @param clazz 实体类
-     * @param type 数据库类型
-     * @return Future
-     */
-    public static Future<Void> migrateTable(Pool pool, Class<?> clazz, JDBCType type) {
-        Promise<Void> promise = Promise.promise();
-        
-        try {
-            String tableName = getTableName(clazz);
-            
-            // 获取带有 @NewField 注解的字段
-            List<Field> newFields = getNewFields(clazz);
-            
-            if (newFields.isEmpty()) {
-                log.debug("表 '{}' 没有标记为 @NewField 的字段，跳过结构检查", tableName);
-                promise.complete();
-                return promise.future();
-            }
-            
-            log.info("开始检查表 '{}' 的结构变更，新增字段数: {}", tableName, newFields.size());
-            
-            // 获取表的所有字段
-            getTableColumns(pool, tableName, type)
-                .compose(existingColumns -> {
-                    // 只添加带有 @NewField 注解且不存在的字段
-                    return addNewFields(pool, clazz, tableName, newFields, existingColumns, type);
-                })
-                .onSuccess(v -> {
-                    log.info("表 '{}' 结构变更完成", tableName);
-                    promise.complete();
-                })
-                .onFailure(err -> {
-                    log.error("表 '{}' 结构变更失败", tableName, err);
-                    promise.fail(err);
-                });
-                
-        } catch (Exception e) {
-            log.error("检查表结构失败", e);
-            promise.fail(e);
-        }
-        
-        return promise.future();
-    }
-
-    /**
-     * 获取带有 @NewField 注解的字段列表
-     */
-    private static List<Field> getNewFields(Class<?> clazz) {
-        List<Field> newFields = new ArrayList<>();
-        for (Field field : clazz.getDeclaredFields()) {
-            if (field.isAnnotationPresent(NewField.class) && !isIgnoredField(field)) {
-                newFields.add(field);
-                String desc = field.getAnnotation(NewField.class).value();
-                if (StringUtils.isNotEmpty(desc)) {
-                    log.debug("发现新字段: {} - {}", field.getName(), desc);
-                } else {
-                    log.debug("发现新字段: {}", field.getName());
-                }
-            }
-        }
-        return newFields;
-    }
-
-    /**
-     * 获取表名
-     */
-    private static String getTableName(Class<?> clazz) {
-        if (clazz.isAnnotationPresent(Table.class)) {
-            Table annotation = clazz.getAnnotation(Table.class);
-            if (StringUtils.isNotEmpty(annotation.value())) {
-                return annotation.value();
-            }
-        }
-        
-        // 默认使用类名转下划线命名
-        Case caseFormat = SnakeCase.INSTANCE;
-        if (clazz.isAnnotationPresent(RowMapped.class)) {
-            RowMapped annotation = clazz.getAnnotation(RowMapped.class);
-            caseFormat = getCase(annotation.formatter());
-        }
-        return LowerCamelCase.INSTANCE.to(caseFormat, clazz.getSimpleName());
-    }
-
-    /**
-     * 获取表的现有字段
-     */
-    private static Future<Set<String>> getTableColumns(Pool pool, String tableName, JDBCType type) {
-        Promise<Set<String>> promise = Promise.promise();
-        
-        String sql = switch (type) {
-            case MySQL -> String.format(
-                "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '%s'",
-                tableName
-            );
-            case H2DB -> String.format(
-                "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = SCHEMA() AND TABLE_NAME = '%s'",
-                tableName.toUpperCase()
-            );
-            case PostgreSQL -> String.format(
-                "SELECT column_name FROM information_schema.columns WHERE table_name = '%s'",
-                tableName.toLowerCase()
-            );
-        };
-        
-        pool.query(sql).execute()
-            .onSuccess(rows -> {
-                Set<String> columns = new HashSet<>();
-                rows.forEach(row -> {
-                    String columnName = row.getString(0);
-                    if (columnName != null) {
-                        columns.add(columnName.toLowerCase());
-                    }
-                });
-                log.debug("表 '{}' 现有字段: {}", tableName, columns);
-                promise.complete(columns);
-            })
-            .onFailure(err -> {
-                log.warn("获取表 '{}' 字段列表失败，可能表不存在: {}", tableName, err.getMessage());
-                promise.complete(new HashSet<>()); // 返回空集合，触发创建表逻辑
-            });
-        
-        return promise.future();
-    }
-
-
-
-    /**
-     * 添加新字段（只处理带 @NewField 注解的字段）
-     */
-    private static Future<Void> addNewFields(Pool pool, Class<?> clazz, String tableName,
-                                             List<Field> newFields, Set<String> existingColumns,
-                                             JDBCType type) {
-        List<Future<Void>> futures = new ArrayList<>();
-        
-        Case caseFormat = SnakeCase.INSTANCE;
-        if (clazz.isAnnotationPresent(RowMapped.class)) {
-            RowMapped annotation = clazz.getAnnotation(RowMapped.class);
-            caseFormat = getCase(annotation.formatter());
-        }
-        
-        String quotationMarks = type == JDBCType.MySQL ? "`" : "\"";
-        
-        for (Field field : newFields) {
-            // 获取字段名
-            String columnName;
-            if (field.isAnnotationPresent(Column.class)) {
-                Column annotation = field.getAnnotation(Column.class);
-                columnName = StringUtils.isNotEmpty(annotation.name())
-                    ? annotation.name()
-                    : LowerCamelCase.INSTANCE.to(caseFormat, field.getName());
-            } else {
-                columnName = LowerCamelCase.INSTANCE.to(caseFormat, field.getName());
-            }
-            
-            // 检查字段是否已存在
-            if (existingColumns.contains(columnName.toLowerCase())) {
-                log.warn("字段 '{}' 已存在，请移除 @NewField 注解", columnName);
-                continue;
-            }
-            
-            // 生成 ALTER TABLE 语句
-            String sql = buildAlterTableSQL(tableName, field, columnName, quotationMarks, type);
-            
-            log.info("添加字段: {}", sql);
-            
-            Promise<Void> p = Promise.promise();
-            pool.query(sql).execute()
-                .onSuccess(v -> {
-                    log.info("字段 '{}' 添加成功", columnName);
-                    p.complete();
-                })
-                .onFailure(err -> {
-                    String errorMsg = err.getMessage();
-                    // 如果字段已存在，忽略错误（可能是并发执行或检测失败）
-                    if (errorMsg != null && (errorMsg.contains("Duplicate column") || 
-                                            errorMsg.contains("already exists") ||
-                                            errorMsg.contains("duplicate key"))) {
-                        log.warn("字段 '{}' 已存在，跳过添加", columnName);
-                        p.complete();
-                    } else {
-                        log.error("字段 '{}' 添加失败", columnName, err);
-                        p.fail(err);
-                    }
-                });
-            
-            futures.add(p.future());
-        }
-        
-        return Future.all(futures).mapEmpty();
-    }
-
-    /**
-     * 构建 ALTER TABLE 添加字段的 SQL
-     */
-    private static String buildAlterTableSQL(String tableName, Field field, String columnName,
-                                             String quotationMarks, JDBCType type) {
-        StringBuilder sb = new StringBuilder();
-        sb.append("ALTER TABLE ").append(quotationMarks).append(tableName).append(quotationMarks)
-          .append(" ADD COLUMN ").append(quotationMarks).append(columnName).append(quotationMarks);
-        
-        // 获取字段类型
-        String sqlType = CreateTable.javaProperty2SqlColumnMap.get(field.getType());
-        if (sqlType == null) {
-            sqlType = "VARCHAR";
-        }
-        sb.append(" ").append(sqlType);
-        
-        // 添加类型长度
-        int[] decimalSize = {22, 2};
-        int varcharSize = 255;
-        if (field.isAnnotationPresent(Length.class)) {
-            Length length = field.getAnnotation(Length.class);
-            decimalSize = length.decimalSize();
-            varcharSize = length.varcharSize();
-        }
-        
-        if ("DECIMAL".equals(sqlType)) {
-            sb.append("(").append(decimalSize[0]).append(",").append(decimalSize[1]).append(")");
-        } else if ("VARCHAR".equals(sqlType)) {
-            sb.append("(").append(varcharSize).append(")");
-        }
-        
-        // 添加约束
-        if (field.isAnnotationPresent(Constraint.class)) {
-            Constraint constraint = field.getAnnotation(Constraint.class);
-            
-            if (constraint.notNull()) {
-                sb.append(" NOT NULL");
-            }
-            
-            if (StringUtils.isNotEmpty(constraint.defaultValue())) {
-                String apostrophe = constraint.defaultValueIsFunction() ? "" : "'";
-                sb.append(" DEFAULT ").append(apostrophe).append(constraint.defaultValue()).append(apostrophe);
-            }
-        }
-        
-        return sb.toString();
-    }
-
-    /**
-     * 判断是否忽略字段
-     */
-    private static boolean isIgnoredField(Field field) {
-        int modifiers = field.getModifiers();
-        return java.lang.reflect.Modifier.isStatic(modifiers)
-            || java.lang.reflect.Modifier.isTransient(modifiers)
-            || field.isAnnotationPresent(TableGenIgnore.class);
-    }
-
-    /**
-     * 获取 Case 类型
-     */
-    private static Case getCase(Class<?> clz) {
-        return switch (clz.getName()) {
-            case "io.vertx.codegen.format.CamelCase" -> io.vertx.codegen.format.CamelCase.INSTANCE;
-            case "io.vertx.codegen.format.SnakeCase" -> SnakeCase.INSTANCE;
-            case "io.vertx.codegen.format.LowerCamelCase" -> LowerCamelCase.INSTANCE;
-            default -> SnakeCase.INSTANCE;
-        };
-    }
-}

core-database/src/test/java/cn/qaiu/db/ddl/SchemaMigrationTest.java

@@ -1,265 +0,0 @@
-package cn.qaiu.db.ddl;
-
-import cn.qaiu.db.pool.JDBCType;
-import io.vertx.core.Future;
-import io.vertx.core.Vertx;
-import io.vertx.jdbcclient.JDBCPool;
-import io.vertx.sqlclient.templates.annotations.Column;
-import lombok.Data;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.*;
-
-/**
- * SchemaMigration 单元测试
- */
-public class SchemaMigrationTest {
-
-    private Vertx vertx;
-    private JDBCPool pool;
-
-    @Before
-    public void setUp() {
-        vertx = Vertx.vertx();
-        
-        // 创建 H2 内存数据库连接池
-        pool = JDBCPool.pool(vertx,
-            "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
-            "sa",
-            ""
-        );
-    }
-
-    @After
-    public void tearDown() {
-        if (pool != null) {
-            pool.close();
-        }
-        if (vertx != null) {
-            vertx.close();
-        }
-    }
-
-    /**
-     * 测试添加新字段
-     */
-    @Test
-    public void testAddNewField() throws Exception {
-        CountDownLatch latch = new CountDownLatch(1);
-        
-        // 1. 先创建一个基础表
-        String createTableSQL = """
-            CREATE TABLE test_user (
-                id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                name VARCHAR(50) NOT NULL
-            )
-            """;
-        
-        pool.query(createTableSQL).execute()
-            .compose(v -> {
-                // 2. 使用 SchemaMigration 添加新字段
-                return SchemaMigration.migrateTable(pool, TestUserWithNewField.class, JDBCType.H2DB);
-            })
-            .compose(v -> {
-                // 3. 验证新字段是否添加成功
-                return pool.query("SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS " +
-                                "WHERE TABLE_NAME = 'TEST_USER' AND COLUMN_NAME = 'EMAIL'")
-                          .execute();
-            })
-            .onSuccess(rows -> {
-                assertEquals("应该找到新添加的 email 字段", 1, rows.size());
-                latch.countDown();
-            })
-            .onFailure(err -> {
-                fail("测试失败: " + err.getMessage());
-                latch.countDown();
-            });
-        
-        assertTrue("测试超时", latch.await(10, TimeUnit.SECONDS));
-    }
-
-    /**
-     * 测试不添加已存在的字段
-     */
-    @Test
-    public void testSkipExistingField() throws Exception {
-        CountDownLatch latch = new CountDownLatch(1);
-        
-        // 1. 创建包含 email 字段的表
-        String createTableSQL = """
-            CREATE TABLE test_user2 (
-                id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                name VARCHAR(50) NOT NULL,
-                email VARCHAR(100)
-            )
-            """;
-        
-        pool.query(createTableSQL).execute()
-            .compose(v -> {
-                // 2. 尝试再次添加 email 字段（应该跳过）
-                return SchemaMigration.migrateTable(pool, TestUserWithNewField2.class, JDBCType.H2DB);
-            })
-            .onSuccess(v -> {
-                // 3. 验证表结构正常，没有错误
-                latch.countDown();
-            })
-            .onFailure(err -> {
-                fail("测试失败: " + err.getMessage());
-                latch.countDown();
-            });
-        
-        assertTrue("测试超时", latch.await(10, TimeUnit.SECONDS));
-    }
-
-    /**
-     * 测试没有 @NewField 注解时不执行迁移
-     */
-    @Test
-    public void testNoNewFieldAnnotation() throws Exception {
-        CountDownLatch latch = new CountDownLatch(1);
-        
-        // 1. 创建基础表
-        String createTableSQL = """
-            CREATE TABLE test_user3 (
-                id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                name VARCHAR(50) NOT NULL
-            )
-            """;
-        
-        pool.query(createTableSQL).execute()
-            .compose(v -> {
-                // 2. 使用没有 @NewField 注解的实体类
-                return SchemaMigration.migrateTable(pool, TestUserNoAnnotation.class, JDBCType.H2DB);
-            })
-            .compose(v -> {
-                // 3. 验证没有添加 email 字段
-                return pool.query("SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS " +
-                                "WHERE TABLE_NAME = 'TEST_USER3' AND COLUMN_NAME = 'EMAIL'")
-                          .execute();
-            })
-            .onSuccess(rows -> {
-                assertEquals("不应该添加没有 @NewField 注解的字段", 0, rows.size());
-                latch.countDown();
-            })
-            .onFailure(err -> {
-                fail("测试失败: " + err.getMessage());
-                latch.countDown();
-            });
-        
-        assertTrue("测试超时", latch.await(10, TimeUnit.SECONDS));
-    }
-
-    /**
-     * 测试多个新字段同时添加
-     */
-    @Test
-    public void testMultipleNewFields() throws Exception {
-        CountDownLatch latch = new CountDownLatch(1);
-        
-        // 1. 创建基础表
-        String createTableSQL = """
-            CREATE TABLE test_user4 (
-                id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                name VARCHAR(50) NOT NULL
-            )
-            """;
-        
-        pool.query(createTableSQL).execute()
-            .compose(v -> {
-                // 2. 添加多个新字段
-                return SchemaMigration.migrateTable(pool, TestUserMultipleNewFields.class, JDBCType.H2DB);
-            })
-            .compose(v -> {
-                // 3. 验证所有新字段都添加成功
-                return pool.query("SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS " +
-                                "WHERE TABLE_NAME = 'TEST_USER4' AND COLUMN_NAME IN ('EMAIL', 'PHONE', 'ADDRESS')")
-                          .execute();
-            })
-            .onSuccess(rows -> {
-                int count = rows.iterator().next().getInteger(0);
-                assertEquals("应该添加 3 个新字段", 3, count);
-                latch.countDown();
-            })
-            .onFailure(err -> {
-                fail("测试失败: " + err.getMessage());
-                latch.countDown();
-            });
-        
-        assertTrue("测试超时", latch.await(10, TimeUnit.SECONDS));
-    }
-
-    // ========== 测试实体类 ==========
-
-    @Data
-    @Table("test_user")
-    static class TestUserWithNewField {
-        @Constraint(autoIncrement = true)
-        private Long id;
-        
-        @Length(varcharSize = 50)
-        @Constraint(notNull = true)
-        private String name;
-        
-        @NewField("用户邮箱")
-        @Length(varcharSize = 100)
-        private String email;
-    }
-
-    @Data
-    @Table("test_user2")
-    static class TestUserWithNewField2 {
-        @Constraint(autoIncrement = true)
-        private Long id;
-        
-        @Length(varcharSize = 50)
-        @Constraint(notNull = true)
-        private String name;
-        
-        @NewField("用户邮箱")
-        @Length(varcharSize = 100)
-        private String email;
-    }
-
-    @Data
-    @Table("test_user3")
-    static class TestUserNoAnnotation {
-        @Constraint(autoIncrement = true)
-        private Long id;
-        
-        @Length(varcharSize = 50)
-        @Constraint(notNull = true)
-        private String name;
-        
-        // 没有 @NewField 注解
-        @Length(varcharSize = 100)
-        private String email;
-    }
-
-    @Data
-    @Table("test_user4")
-    static class TestUserMultipleNewFields {
-        @Constraint(autoIncrement = true)
-        private Long id;
-        
-        @Length(varcharSize = 50)
-        @Constraint(notNull = true)
-        private String name;
-        
-        @NewField("用户邮箱")
-        @Length(varcharSize = 100)
-        private String email;
-        
-        @NewField("手机号")
-        @Length(varcharSize = 20)
-        private String phone;
-        
-        @NewField("地址")
-        @Length(varcharSize = 255)
-        private String address;
-    }
-}

core/pom.xml

@@ -73,6 +73,12 @@
             <version>${jackson.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
 
     </dependencies>
 

core/src/main/generated/cn/qaiu/vx/core/verticle/conf/HttpProxyConfConverter.java

@@ -1,73 +0,0 @@
-package cn.qaiu.vx.core.verticle.conf;
-
-import io.vertx.core.json.JsonObject;
-import io.vertx.core.json.JsonArray;
-import io.vertx.core.json.impl.JsonUtil;
-import java.time.Instant;
-import java.time.format.DateTimeFormatter;
-import java.util.Base64;
-
-/**
- * Converter and mapper for {@link cn.qaiu.vx.core.verticle.conf.HttpProxyConf}.
- * NOTE: This class has been automatically generated from the {@link cn.qaiu.vx.core.verticle.conf.HttpProxyConf} original class using Vert.x codegen.
- */
-public class HttpProxyConfConverter {
-
-
-  private static final Base64.Decoder BASE64_DECODER = JsonUtil.BASE64_DECODER;
-  private static final Base64.Encoder BASE64_ENCODER = JsonUtil.BASE64_ENCODER;
-
-   static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, HttpProxyConf obj) {
-    for (java.util.Map.Entry<String, Object> member : json) {
-      switch (member.getKey()) {
-        case "password":
-          if (member.getValue() instanceof String) {
-            obj.setPassword((String)member.getValue());
-          }
-          break;
-        case "port":
-          if (member.getValue() instanceof Number) {
-            obj.setPort(((Number)member.getValue()).intValue());
-          }
-          break;
-        case "preProxyOptions":
-          if (member.getValue() instanceof JsonObject) {
-            obj.setPreProxyOptions(new io.vertx.core.net.ProxyOptions((io.vertx.core.json.JsonObject)member.getValue()));
-          }
-          break;
-        case "timeout":
-          if (member.getValue() instanceof Number) {
-            obj.setTimeout(((Number)member.getValue()).intValue());
-          }
-          break;
-        case "username":
-          if (member.getValue() instanceof String) {
-            obj.setUsername((String)member.getValue());
-          }
-          break;
-      }
-    }
-  }
-
-   static void toJson(HttpProxyConf obj, JsonObject json) {
-    toJson(obj, json.getMap());
-  }
-
-   static void toJson(HttpProxyConf obj, java.util.Map<String, Object> json) {
-    if (obj.getPassword() != null) {
-      json.put("password", obj.getPassword());
-    }
-    if (obj.getPort() != null) {
-      json.put("port", obj.getPort());
-    }
-    if (obj.getPreProxyOptions() != null) {
-      json.put("preProxyOptions", obj.getPreProxyOptions().toJson());
-    }
-    if (obj.getTimeout() != null) {
-      json.put("timeout", obj.getTimeout());
-    }
-    if (obj.getUsername() != null) {
-      json.put("username", obj.getUsername());
-    }
-  }
-}

core/src/main/java/cn/qaiu/vx/core/Deploy.java

@@ -3,12 +3,13 @@ package cn.qaiu.vx.core;
 import cn.qaiu.vx.core.util.CommonUtil;
 import cn.qaiu.vx.core.util.ConfigUtil;
 import cn.qaiu.vx.core.util.VertxHolder;
+import cn.qaiu.vx.core.verticle.HttpProxyVerticle;
+import cn.qaiu.vx.core.verticle.PostExecVerticle;
 import cn.qaiu.vx.core.verticle.ReverseProxyVerticle;
 import cn.qaiu.vx.core.verticle.RouterVerticle;
 import cn.qaiu.vx.core.verticle.ServiceVerticle;
 import io.vertx.core.*;
 import io.vertx.core.dns.AddressResolverOptions;
-import io.vertx.core.impl.launcher.commands.VersionCommand;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.shareddata.LocalMap;
 import org.slf4j.Logger;
@@ -17,6 +18,7 @@ import org.slf4j.LoggerFactory;
 import java.lang.management.ManagementFactory;
 import java.util.Calendar;
 import java.util.Date;
+import java.util.UUID;
 import java.util.concurrent.locks.LockSupport;
 
 import static cn.qaiu.vx.core.util.ConfigConstant.*;
@@ -54,6 +56,7 @@ public final class Deploy {
     public void start(String[] args, Handler<JsonObject> handle) {
         this.mainThread = Thread.currentThread();
         this.handle = handle;
+
         if (args.length > 0 && args[0].startsWith("app-")) {
             // 启动参数dev或者prod
             path.append("-").append(args[0].replace("app-",""));
@@ -104,7 +107,7 @@ public final class Deploy {
 
         System.out.printf(logoTemplate,
                 CommonUtil.getAppVersion(),
-                VersionCommand.getVersion(),
+                "4x",
                 conf.getString("copyright"),
                 year
         );
@@ -123,12 +126,12 @@ public final class Deploy {
         var vertxOptions = vertxConfigELPS == 0 ?
                 new VertxOptions() : new VertxOptions(vertxConfig);
 
-        vertxOptions.setAddressResolverOptions(
-                new AddressResolverOptions().
-                        addServer("114.114.114.114").
-                        addServer("114.114.115.115").
-                        addServer("8.8.8.8").
-                        addServer("8.8.4.4"));
+//        vertxOptions.setAddressResolverOptions(
+//                new AddressResolverOptions().
+//                        addServer("114.114.114.114").
+//                        addServer("114.114.115.115").
+//                        addServer("8.8.8.8").
+//                        addServer("8.8.4.4"));
         LOGGER.info("vertxConfigEventLoopPoolSize: {}, eventLoopPoolSize: {}, workerPoolSize: {}", vertxConfigELPS,
                 vertxOptions.getEventLoopPoolSize(),
                 vertxOptions.getWorkerPoolSize());
@@ -153,12 +156,39 @@ public final class Deploy {
             var future2 = vertx.deployVerticle(ServiceVerticle.class, getWorkDeploymentOptions("Service"));
             var future3 = vertx.deployVerticle(ReverseProxyVerticle.class, getWorkDeploymentOptions("proxy"));
 
-            Future.all(future1, future2, future3)
-                    .onSuccess(this::deployWorkVerticalSuccess)
-                    .onFailure(this::deployVerticalFailed);
+
+            JsonObject jsonObject = ((JsonObject) localMap.get(GLOBAL_CONFIG)).getJsonObject("proxy-server");
+            if (jsonObject != null) {
+                genPwd(jsonObject);
+                var future4 = vertx.deployVerticle(HttpProxyVerticle.class, getWorkDeploymentOptions("proxy"));
+                future4.onSuccess(LOGGER::info);
+                future4.onFailure(e -> LOGGER.error("Other handle error", e));
+                Future.all(future1, future2, future3, future4)
+                        .onSuccess(this::deployWorkVerticalSuccess)
+                        .onFailure(this::deployVerticalFailed);
+            } else {
+                Future.all(future1, future2, future3)
+                        .onSuccess(this::deployWorkVerticalSuccess)
+                        .onFailure(this::deployVerticalFailed);
+            }
+
         }).onFailure(e -> LOGGER.error("Other handle error", e));
     }
 
+    private static void genPwd(JsonObject jsonObject) {
+        if (jsonObject.getBoolean("randUserPwd")) {
+            var username = UUID.randomUUID().toString().replace("-", "").substring(0, 16);
+            var password = UUID.randomUUID().toString().replace("-", "").substring(0, 16);
+            jsonObject.put("username", username);
+            jsonObject.put("password", password);
+        }
+        LOGGER.info("=============server info=================");
+        LOGGER.info("\nport: {}\nusername: {}\npassword: {}",
+                jsonObject.getString("port"),
+                jsonObject.getString("username"),
+                jsonObject.getString("password"));
+        LOGGER.info("==============server info================");
+    }
     /**
      * 部署失败
      *
@@ -178,6 +208,42 @@ public final class Deploy {
         var t1 = ((double) (System.currentTimeMillis() - startTime)) / 1000;
         var t2 = ((double) System.currentTimeMillis() - ManagementFactory.getRuntimeMXBean().getStartTime()) / 1000;
         LOGGER.info("web服务启动成功 -> 用时: {}s, jvm启动用时: {}s", t1, t2);
+
+        // 检查是否处于安装引导模式（数据库未配置）
+        Object installMode = VertxHolder.getVertxInstance().sharedData()
+                .getLocalMap(LOCAL).get("installMode");
+        if (Boolean.TRUE.equals(installMode)) {
+            LOGGER.info("系统处于安装引导模式，等待用户完成数据库配置后再启动后置初始化...");
+            return;
+        }
+
+        // 正常模式：部署 PostExecVerticle 执行 AppRun 实现
+        deployPostExec();
+    }
+
+    /**
+     * 部署 PostExecVerticle（执行所有 AppRun 实现）
+     * 安装引导完成后也可手动调用此方法触发后置初始化
+     */
+    public void deployPostExec() {
+        var vertx = VertxHolder.getVertxInstance();
+        var postExecFuture = vertx.deployVerticle(PostExecVerticle.class, getWorkDeploymentOptions("postExec", 2));
+        postExecFuture.onSuccess(id -> {
+            LOGGER.info("PostExecVerticle 部署成功，AppRun 实现执行完成");
+        }).onFailure(e -> {
+            LOGGER.error("PostExecVerticle 部署失败", e);
+        });
+    }
+
+    /**
+     * 重新部署 ServiceVerticle，重新注册因 DB 未就绪而失败的服务到 EventBus
+     * 安装引导完成、DB 初始化后调用
+     */
+    public void redeployServices() {
+        var vertx = VertxHolder.getVertxInstance();
+        vertx.deployVerticle(ServiceVerticle.class, getWorkDeploymentOptions("Service"))
+                .onSuccess(id -> LOGGER.info("ServiceVerticle 重新部署成功，DB 相关服务已注册"))
+                .onFailure(e -> LOGGER.error("ServiceVerticle 重新部署失败", e));
     }
 
     /**

core/src/main/java/cn/qaiu/vx/core/annotaions/HandleSortFilter.java

@@ -9,6 +9,7 @@ import java.lang.annotation.*;
 public @interface HandleSortFilter {
     /**
      * 注册顺序，数字越大越先注册<br>
+     * 前置拦截器会先执行后注册即数字小的, 后置拦截器会先执行先注册的即数字大的<br>
      * 值<0时会过滤掉该处理器
      */
     int value() default 0;

core/src/main/java/cn/qaiu/vx/core/base/AppRun.java

@@ -0,0 +1,12 @@
+package cn.qaiu.vx.core.base;
+
+import io.vertx.core.json.JsonObject;
+
+public interface AppRun {
+
+    /**
+     * 执行方法
+     * @param config 启动配置文件
+     */
+    void execute(JsonObject config);
+}

core/src/main/java/cn/qaiu/vx/core/base/BaseHttpApi.java

@@ -38,6 +38,20 @@ public interface BaseHttpApi {
         handleAfterInterceptor(ctx, jsonResult.toJsonObject());
     }
 
+    default void doFireJsonObjectResponse(RoutingContext ctx, JsonObject jsonObject, int statusCode) {
+        if (!ctx.response().ended()) {
+            fireJsonObjectResponse(ctx, jsonObject, statusCode);
+        }
+        handleAfterInterceptor(ctx, jsonObject);
+    }
+
+
+    default <T> void doFireJsonResultResponse(RoutingContext ctx, JsonResult<T> jsonResult, int statusCode) {
+        if (!ctx.response().ended()) {
+            fireJsonResultResponse(ctx, jsonResult, statusCode);
+        }
+        handleAfterInterceptor(ctx, jsonResult.toJsonObject());
+    }
 
     default Set<AfterInterceptor> getAfterInterceptor() {
 

core/src/main/java/cn/qaiu/vx/core/base/DefaultAppRun.java

@@ -0,0 +1,23 @@
+package cn.qaiu.vx.core.base;
+
+import cn.qaiu.vx.core.annotaions.HandleSortFilter;
+import io.vertx.core.json.JsonObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 默认的AppRun实现示例
+ * <br>Create date 2024-01-01 00:00:00
+ *
+ * @author <a href="https://qaiu.top">QAIU</a>
+ */
+@HandleSortFilter
+public class DefaultAppRun implements AppRun {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultAppRun.class);
+
+    @Override
+    public void execute(JsonObject config) {
+        LOGGER.info("======> AppRun实现类开始执行，配置数: {}", config.size());
+    }
+}

core/src/main/java/cn/qaiu/vx/core/handlerfactory/RouterHandlerFactory.java

@@ -23,8 +23,6 @@ import io.vertx.ext.web.RoutingContext;
 import io.vertx.ext.web.handler.*;
 import io.vertx.ext.web.handler.sockjs.SockJSHandler;
 import io.vertx.ext.web.handler.sockjs.SockJSHandlerOptions;
-import io.vertx.ext.web.sstore.LocalSessionStore;
-import io.vertx.ext.web.sstore.SessionStore;
 import javassist.CtClass;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
@@ -69,120 +67,22 @@ public class RouterHandlerFactory implements BaseHttpApi {
         this.gatewayPrefix = gatewayPrefix;
     }
 
-    /**
-     * 在主路由上直接注册 WebSocket 路由
-     * 必须使用 order(-1000) 确保在所有拦截器之前执行
-     */
-    private void registerWebSocketRoutes(Router mainRouter) {
-        try {
-            Set<Class<?>> handlers = reflections.getTypesAnnotatedWith(RouteHandler.class);
-            for (Class<?> handler : handlers) {
-                String root = getRootPath(handler);
-                Method[] methods = handler.getMethods();
-                
-                for (Method method : methods) {
-                    if (method.isAnnotationPresent(SockRouteMapper.class)) {
-                        SockRouteMapper mapping = method.getAnnotation(SockRouteMapper.class);
-                        String routeUrl = getRouteUrl(mapping.value());
-                        String url = root.concat(routeUrl);
-                        
-                        // 在这里创建实例，确保每个 handler 使用同一个实例
-                        final Object instance = ReflectionUtil.newWithNoParam(handler);
-                        final Method finalMethod = method;
-                        
-                        LOGGER.info("========================================");
-                        LOGGER.info("注册 WebSocket Handler (主路由，优先级最高):");
-                        LOGGER.info("  类: {}", handler.getName());
-                        LOGGER.info("  方法: {}", method.getName());
-                        LOGGER.info("  实例: {}", instance.getClass().getName());
-                        LOGGER.info("  完整路径: {}/*", url);
-                        LOGGER.info("========================================");
-                        
-                        SockJSHandlerOptions options = new SockJSHandlerOptions()
-                                .setHeartbeatInterval(2000)
-                                .setRegisterWriteHandler(true);
-
-                        SockJSHandler sockJSHandler = SockJSHandler.create(VertxHolder.getVertxInstance(), options);
-                        
-                        // SockJS 路径处理
-                        String sockJsPath = url;
-                        while (sockJsPath.endsWith("/") || sockJsPath.endsWith("*")) {
-                            sockJsPath = sockJsPath.substring(0, sockJsPath.length() - 1);
-                        }
-                        final String finalSockJsPath = sockJsPath;
-                        
-                        // ✅ socketHandler() 返回 Router，用于挂载
-                        // 使用 final 变量确保闭包中引用正确
-                        Router sockJsRouter = sockJSHandler.socketHandler(sock -> {
-                            LOGGER.info("[WS] ==========================================");
-                            LOGGER.info("[WS] SockJS socketHandler 回调被调用!");
-                            LOGGER.info("[WS] Socket ID: {}", sock.writeHandlerID());
-                            LOGGER.info("[WS] Remote Address: {}", sock.remoteAddress());
-                            LOGGER.info("[WS] Local Address: {}", sock.localAddress());
-                            LOGGER.info("[WS] 即将调用 method: {}.{}", instance.getClass().getSimpleName(), finalMethod.getName());
-                            LOGGER.info("[WS] ==========================================");
-                            try {
-                                finalMethod.invoke(instance, sock);
-                                LOGGER.info("[WS] Handler 调用成功");
-                            } catch (Throwable e) {
-                                LOGGER.error("[WS] WebSocket handler 调用失败", e);
-                                if (e.getCause() != null) {
-                                    LOGGER.error("[WS] 原始异常", e.getCause());
-                                }
-                            }
-                        });
-                        
-                        // 添加调试 handler 来检查请求是否到达 SockJS 路径
-                        // 注意：使用 "path*" 格式与 SockJS subRouter 保持一致
-                        mainRouter.route(finalSockJsPath + "*").order(-1001).handler(ctx -> {
-                            LOGGER.info("[WS-DEBUG] 请求到达 SockJS 路径: {}", ctx.request().path());
-                            LOGGER.info("[WS-DEBUG] Method: {}, Upgrade: {}, Connection: {}", 
-                                ctx.request().method(), 
-                                ctx.request().headers().get("Upgrade"),
-                                ctx.request().headers().get("Connection"));
-                            ctx.next();
-                        });
-                        
-                        // 为 SockJS xhr/xhr_send 路径添加 BodyHandler
-                        // 必须在 SockJS 路由之前，但 WebSocket 升级请求不需要
-                        mainRouter.route(finalSockJsPath + "*").order(-1000).handler(BodyHandler.create());
-                        
-                        // ✅ 挂载 SockJS 路由 - 注意：subRouter 需要使用 "path*" 格式而不是 "path/*"
-                        mainRouter.route(finalSockJsPath + "*").order(-999).subRouter(sockJsRouter);
-                        
-                        LOGGER.info("✅ WebSocket 路由注册完成: {} (order=-1000)", finalSockJsPath);
-                        LOGGER.info("   SockJS 端点: {}/info, {}/websocket, {}/xhr", finalSockJsPath, finalSockJsPath, finalSockJsPath);
-                    }
-                }
-            }
-        } catch (Exception e) {
-            LOGGER.error("注册 WebSocket 路由失败", e);
-        }
-    }
-
     /**
      * 开始扫描并注册handler
      */
     public Router createRouter() {
         // 主路由
         Router mainRouter = Router.router(VertxHolder.getVertxInstance());
-        
-        // ⚠️ 重要：先注册 WebSocket 路由，必须在所有 handler 之前
-        // SockJSHandler 不能在 subRouter 中，必须直接挂载到主路由
-        // 注意：WebSocket 路由必须在 BodyHandler 之前注册，否则会干扰 WebSocket 升级
-        registerWebSocketRoutes(mainRouter);
-        
         mainRouter.route().handler(ctx -> {
             String realPath = ctx.request().uri();
-            
             if (realPath.startsWith(REROUTE_PATH_PREFIX)) {
                 // vertx web proxy暂不支持rewrite, 所以这里进行手动替换, 请求地址中的请求path前缀替换为originPath
-                String rePath = realPath.substring(REROUTE_PATH_PREFIX.length());
+                String rePath = realPath.replace(REROUTE_PATH_PREFIX, "");
                 ctx.reroute(rePath);
                 return;
             }
 
-            LOGGER.debug("The HTTP service request address information ===>path:{}, uri:{}, method:{}",
+            LOGGER.debug("New request:{}, {}, {}",
                     ctx.request().path(), ctx.request().absoluteURI(), ctx.request().method());
             ctx.response().headers().add(ACCESS_CONTROL_ALLOW_ORIGIN, "*");
             ctx.response().headers().add(DATE, LocalDateTime.now().format(ISO_LOCAL_DATE_TIME));
@@ -196,24 +96,11 @@ public class RouterHandlerFactory implements BaseHttpApi {
         mainRouter.route().handler(CorsHandler.create().addRelativeOrigin(".*").allowCredentials(true).allowedMethods(httpMethods));
 
         // 配置文件上传路径
-        // BodyHandler 用于处理 POST 请求体
-        // SockJS 的 xhr/xhr_send 端点需要 BodyHandler，但 WebSocket 升级请求不需要
-        // 因此为 SockJS 路径单独配置 BodyHandler（排除 websocket 子路径）
         mainRouter.route().handler(BodyHandler.create().setUploadsDirectory("uploads"));
 
-        // 配置Session管理 - 用于演练场登录状态持久化
-        // 30天过期时间（毫秒）- 排除 WebSocket 路径
-        SessionStore sessionStore = LocalSessionStore.create(VertxHolder.getVertxInstance());
-        SessionHandler sessionHandler = SessionHandler.create(sessionStore)
-                .setSessionTimeout(30L * 24 * 60 * 60 * 1000) // 30天
-                .setSessionCookieName("SESSIONID") // Cookie名称
-                .setCookieHttpOnlyFlag(true) // 防止XSS攻击
-                .setCookieSecureFlag(false); // 非HTTPS环境设置为false
-        mainRouter.routeWithRegex("^(?!/v2/ws/).*").handler(sessionHandler);
-
-        // 拦截器 - 排除 WebSocket 路径
+        // 拦截器
         Set<Handler<RoutingContext>> interceptorSet = getInterceptorSet();
-        Route route0 = mainRouter.routeWithRegex("^(?!/v2/ws/).*");
+        Route route0 = mainRouter.route("/*");
         interceptorSet.forEach(route0::handler);
 
         try {
@@ -290,16 +177,34 @@ public class RouterHandlerFactory implements BaseHttpApi {
                     if (ctx.response().ended()) return;
                     // 超时处理器状态码503
                     if (ctx.statusCode() == 503 || ctx.failure() == null) {
-                        doFireJsonResultResponse(ctx, JsonResult.error("未知异常, 请联系管理员", 500));
+                        doFireJsonResultResponse(ctx, JsonResult.error("未知异常, 请联系管理员"), 503);
                     } else {
                         ctx.failure().printStackTrace();
-                        doFireJsonResultResponse(ctx, JsonResult.error(ctx.failure().getMessage(), 500));
+                        doFireJsonResultResponse(ctx, JsonResult.error(ctx.failure().getMessage()), 500);
                     }
                 });
             } else if (method.isAnnotationPresent(SockRouteMapper.class)) {
-                // WebSocket 路由已在 registerWebSocketRoutes() 中提前注册
-                // 跳过此处，避免重复注册
-                continue;
+                // websocket 基于sockJs
+                SockRouteMapper mapping = method.getAnnotation(SockRouteMapper.class);
+                String routeUrl = getRouteUrl(mapping.value());
+                String url = root.concat(routeUrl);
+                LOGGER.info("Register New Websocket Handler -> {}", url);
+                SockJSHandlerOptions options = new SockJSHandlerOptions()
+                        .setHeartbeatInterval(2000)
+                        .setRegisterWriteHandler(true);
+
+                SockJSHandler sockJSHandler = SockJSHandler.create(VertxHolder.getVertxInstance(), options);
+                Router route = sockJSHandler.socketHandler(sock -> {
+                    try {
+                        ReflectionUtil.invokeWithArguments(method, instance, sock);
+                    } catch (Throwable e) {
+                        e.printStackTrace();
+                    }
+                });
+                if (url.endsWith("*")) {
+                    throw new IllegalArgumentException("Don't include * when mounting a sub router");
+                }
+                router.route(url + "*").subRouter(route);
             }
         }
     }
@@ -329,7 +234,7 @@ public class RouterHandlerFactory implements BaseHttpApi {
      */
     private Set<Handler<RoutingContext>> getInterceptorSet() {
         // 配置拦截
-        return getBeforeInterceptor().stream().map(BeforeInterceptor::doHandle).collect(Collectors.toSet());
+        return getBeforeInterceptor().stream().map(BeforeInterceptor::doHandle).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     /**
@@ -398,18 +303,19 @@ public class RouterHandlerFactory implements BaseHttpApi {
 
         final MultiMap queryParams = ctx.queryParams();
         // 解析body-json参数
-        // 只处理POST/PUT/PATCH等有body的请求方法，避免GET请求读取body导致"Request has already been read"错误
-        String httpMethod = ctx.request().method().name();
-        if (("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod))
-                && HttpHeaderValues.APPLICATION_JSON.toString().equals(ctx.parsedHeaders().contentType().value())
-                && ctx.body() != null && ctx.body().asJsonObject() != null) {
+        if (HttpHeaderValues.APPLICATION_JSON.toString().equals(ctx.parsedHeaders().contentType().value())) {
             JsonObject body = ctx.body().asJsonObject();
             if (body != null) {
                 methodParametersTemp.forEach((k, v) -> {
+                    String typeName = v.getRight().getName();
+                    // 直接绑定 JsonObject 类型参数
+                    if (JsonObject.class.getName().equals(typeName)) {
+                        parameterValueList.put(k, body);
+                    }
                     // 只解析已配置包名前缀的实体类
-                    if (CommonUtil.matchRegList(entityPackagesReg.getList(), v.getRight().getName())) {
+                    else if (CommonUtil.matchRegList(entityPackagesReg.getList(), typeName)) {
                         try {
-                            Class<?> aClass = Class.forName(v.getRight().getName());
+                            Class<?> aClass = Class.forName(typeName);
                             JsonObject data = CommonUtil.getSubJsonForEntity(body, aClass);
                             if (!data.isEmpty()) {
                                 Object entity = data.mapTo(aClass);
@@ -418,12 +324,20 @@ public class RouterHandlerFactory implements BaseHttpApi {
                         } catch (ClassNotFoundException e) {
                             e.printStackTrace();
                         }
-
                     }
                 });
+            } else {
+                // body 可能是 JsonArray
+                JsonArray bodyArray = ctx.body().asJsonArray();
+                if (bodyArray != null) {
+                    methodParametersTemp.forEach((k, v) -> {
+                        if (JsonArray.class.getName().equals(v.getRight().getName())) {
+                            parameterValueList.put(k, bodyArray);
+                        }
+                    });
+                }
             }
-        } else if (("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod))
-                && ctx.body() != null) {
+        } else if (ctx.body() != null) {
             queryParams.addAll(ParamUtil.paramsToMap(ctx.body().asString()));
         }
 
@@ -453,6 +367,20 @@ public class RouterHandlerFactory implements BaseHttpApi {
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
+            } else if (parameterValueList.get(k) == null
+                    && JsonObject.class.getName().equals(v.getRight().getName())) {
+                // 兜底: content-type 非 application/json 时尝试从 body 解析 JsonObject
+                if (ctx.body() != null) {
+                    JsonObject jo = ctx.body().asJsonObject();
+                    if (jo != null) parameterValueList.put(k, jo);
+                }
+            } else if (parameterValueList.get(k) == null
+                    && JsonArray.class.getName().equals(v.getRight().getName())) {
+                // 兜底: content-type 非 application/json 时尝试从 body 解析 JsonArray
+                if (ctx.body() != null) {
+                    JsonArray ja = ctx.body().asJsonArray();
+                    if (ja != null) parameterValueList.put(k, ja);
+                }
             }
         });
         // 调用handle 获取响应对象
@@ -462,25 +390,25 @@ public class RouterHandlerFactory implements BaseHttpApi {
             Object data = ReflectionUtil.invokeWithArguments(method, instance, parameterValueArray);
             if (data != null) {
 
-                if (data instanceof JsonResult) {
-                    doFireJsonResultResponse(ctx, (JsonResult<?>) data);
+                if (data instanceof JsonResult jsonResult) {
+                    doFireJsonResultResponse(ctx, (JsonResult<?>) data, jsonResult.getCode());
                 }
                 if (data instanceof JsonObject) {
                     doFireJsonObjectResponse(ctx, ((JsonObject) data));
                 } else if (data instanceof Future) { // 处理异步响应
                     ((Future<?>) data).onSuccess(res -> {
-                        if (res instanceof JsonResult) {
-                            doFireJsonResultResponse(ctx, (JsonResult<?>) res);
+                        if (res instanceof JsonResult jsonResult) {
+                            doFireJsonResultResponse(ctx, jsonResult, jsonResult.getCode());
                         }
                         if (res instanceof JsonObject) {
                             doFireJsonObjectResponse(ctx, ((JsonObject) res));
                         } else if (res != null) {
                             doFireJsonResultResponse(ctx, JsonResult.data(res));
                         } else {
-                            handleAfterInterceptor(ctx, null);
+                            doFireJsonResultResponse(ctx, JsonResult.data(null));
                         }
 
-                    }).onFailure(e -> doFireJsonResultResponse(ctx, JsonResult.error(e.getMessage())));
+                    }).onFailure(e -> doFireJsonResultResponse(ctx, JsonResult.error(e.getMessage()), 500));
                 } else {
                     doFireJsonResultResponse(ctx, JsonResult.data(data));
                 }
@@ -495,7 +423,7 @@ public class RouterHandlerFactory implements BaseHttpApi {
                     err = e.getCause().getMessage();
                 }
             }
-            doFireJsonResultResponse(ctx, JsonResult.error(err));
+            doFireJsonResultResponse(ctx, JsonResult.error(err), 500);
         }
     }
 

core/src/main/java/cn/qaiu/vx/core/interceptor/BeforeInterceptor.java

@@ -3,10 +3,12 @@ package cn.qaiu.vx.core.interceptor;
 import io.vertx.core.Handler;
 import io.vertx.ext.web.RoutingContext;
 
-import static cn.qaiu.vx.core.util.ResponseUtil.sendError;
-
 /**
  * 前置拦截器接口
+ * <p>
+ * 注意：Vert.x是异步非阻塞框架，不能在Event Loop中使用synchronized等阻塞操作！
+ * 所有操作都应该是非阻塞的，使用Vert.x的上下文数据存储机制保证线程安全。
+ * </p>
  *
  * @author <a href="https://qaiu.top">QAIU</a>
  */
@@ -14,28 +16,25 @@ public interface BeforeInterceptor extends Handler<RoutingContext> {
     String IS_NEXT = "RoutingContextIsNext";
 
     default Handler<RoutingContext> doHandle() {
-
         return ctx -> {
-            // 加同步锁
-            synchronized (BeforeInterceptor.class) {
-                ctx.put(IS_NEXT, false);
-                BeforeInterceptor.this.handle(ctx);
-                if (!(Boolean) ctx.get(IS_NEXT) && !ctx.response().ended()) {
-                    sendError(ctx, 403);
-                }
-            }
+            // 【优化】移除synchronized锁，Vert.x的RoutingContext本身就是线程安全的
+            // 每个请求都有独立的RoutingContext，不需要额外加锁
+            ctx.put(IS_NEXT, false);
+            handle(ctx); // 调用具体的处理逻辑
+            // 确保如果没有调用doNext()并且响应未结束，则返回错误
+            // if (!(Boolean) ctx.get(IS_NEXT) && !ctx.response().ended()) {
+            //     sendError(ctx, 403);
+            // }
         };
     }
 
     default void doNext(RoutingContext context) {
-        // 设置上下文状态为可以继续执行
-        // 添加同步锁保障多线程下执行时序
-        synchronized (BeforeInterceptor.class) {
-            context.put(IS_NEXT, true);
-            context.next();
-        }
+        // 【优化】移除synchronized锁
+        // RoutingContext的put和next操作是线程安全的，不需要额外同步
+        context.put(IS_NEXT, true);
+        context.next(); // 继续执行下一个处理器
     }
 
-    void handle(RoutingContext context);
-
+    void handle(RoutingContext context); // 实现具体的拦截处理逻辑
 }
+

core/src/main/java/cn/qaiu/vx/core/model/JsonResult.java

@@ -30,7 +30,7 @@ public class JsonResult<T> implements Serializable {
 
     private int code = SUCCESS_CODE;//状态码
 
-    private String msg = SUCCESS_MESSAGE; //消息
+    private String msg = SUCCESS_MESSAGE;//消息
 
     private boolean success = true; //是否成功
 

core/src/main/java/cn/qaiu/vx/core/package-info.java

@@ -1,7 +1,7 @@
 /**
  * ModuleGen cn.qaiu.vx.core
  */
-@ModuleGen(name = "vertx-http-proxy", groupPackage = "cn.qaiu.vx.core", useFutures = true)
+@ModuleGen(name = "vertx-http-proxy", groupPackage = "cn.qaiu.vx.core")
 package cn.qaiu.vx.core;
 
 import io.vertx.codegen.annotations.ModuleGen;

core/src/main/java/cn/qaiu/vx/core/util/AsyncServiceUtil.java

@@ -5,7 +5,7 @@ import io.vertx.serviceproxy.ServiceProxyBuilder;
 
 /**
  * @author Xu Haidong
- * Create at 2018/8/15
+ * @date 2018/8/15
  */
 public final class AsyncServiceUtil {
 

core/src/main/java/cn/qaiu/vx/core/util/CommonUtil.java

@@ -13,6 +13,7 @@ import java.net.Socket;
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.util.List;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
@@ -117,7 +118,7 @@ public class CommonUtil {
         return set.stream().filter(c1 -> {
             HandleSortFilter s1 = c1.getAnnotation(HandleSortFilter.class);
             if (s1 != null) {
-                return s1.value() > 0;
+                return s1.value() >= 0;
             } else {
                 return true;
             }
@@ -138,7 +139,7 @@ public class CommonUtil {
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
-        }).collect(Collectors.toSet());
+        }).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     private static String appVersion;

core/src/main/java/cn/qaiu/vx/core/util/ConfigUtil.java

@@ -4,9 +4,13 @@ import io.vertx.config.ConfigRetriever;
 import io.vertx.config.ConfigRetrieverOptions;
 import io.vertx.config.ConfigStoreOptions;
 import io.vertx.core.Future;
+import io.vertx.core.Promise;
 import io.vertx.core.Vertx;
 import io.vertx.core.json.JsonObject;
 
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+
 /**
  * 异步读取配置工具类
  * <br>Create date 2021/9/2 1:23
@@ -24,7 +28,29 @@ public class ConfigUtil {
      * @return JsonObject的Future
      */
     public static Future<JsonObject> readConfig(String format, String path, Vertx vertx) {
-        // 读取yml配置
+        // 支持 classpath: 前缀从类路径读取，否则从文件系统读取
+        if (path != null && path.startsWith("classpath:")) {
+            String resource = path.substring("classpath:".length());
+            // 使用 executeBlocking(Callable) 直接返回 Future<JsonObject>
+            return vertx.executeBlocking(() -> {
+                InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(resource);
+                if (is == null) {
+                    throw new RuntimeException("classpath resource not found: " + resource);
+                }
+                try (InputStream in = is) {
+                    byte[] bytes = in.readAllBytes();
+                    String content = new String(bytes, StandardCharsets.UTF_8);
+                    if ("json".equalsIgnoreCase(format)) {
+                        return new JsonObject(content);
+                    } else {
+                        throw new RuntimeException("unsupported classpath format: " + format);
+                    }
+                }
+            });
+        }
+
+        Promise<JsonObject> promise = Promise.promise();
+
         ConfigStoreOptions store = new ConfigStoreOptions()
                 .setType("file")
                 .setFormat(format)
@@ -33,10 +59,22 @@ public class ConfigUtil {
         ConfigRetriever retriever = ConfigRetriever
                 .create(vertx, new ConfigRetrieverOptions().addStore(store));
 
-        return retriever.getConfig();
+        // 异步获取配置
+        // 成功直接完成 promise
+        retriever.getConfig()
+                .onSuccess(promise::complete)
+                .onFailure(err -> {
+                    // 配置读取失败，直接返回失败 Future
+                    promise.fail(new RuntimeException(
+                            "读取配置文件失败: " + path, err));
+                    retriever.close();
+                });
+
+        return promise.future();
     }
 
 
+
     /**
      * 异步读取Yaml配置文件
      *

core/src/main/java/cn/qaiu/vx/core/util/FutureUtils.java

@@ -0,0 +1,20 @@
+package cn.qaiu.vx.core.util;
+
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+
+import java.util.concurrent.ExecutionException;
+
+public class FutureUtils {
+
+   public static <T> T getResult(Future<T> future) {
+       try {
+           return future.toCompletionStage().toCompletableFuture().get();
+       } catch (InterruptedException | ExecutionException e) {
+           throw new RuntimeException(e);
+       }
+   }
+    public static <T> T getResult(Promise<T> promise) {
+       return promise.future().toCompletionStage().toCompletableFuture().join();
+    }
+}

core/src/main/java/cn/qaiu/vx/core/util/JacksonConfig.java

@@ -16,7 +16,7 @@ import java.time.format.DateTimeFormatter;
 
 /**
  * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2023/10/14 9:07
+ * @date 2023/10/14 9:07
  */
 public class JacksonConfig {
 

core/src/main/java/cn/qaiu/vx/core/util/ReflectionUtil.java

@@ -36,6 +36,8 @@ import static cn.qaiu.vx.core.util.ConfigConstant.BASE_LOCATIONS;
  */
 public final class ReflectionUtil {
 
+    // 缓存Reflections实例，避免重复扫描（每次扫描约35K+值，耗时1-3秒，占用大量内存）
+    private static final Map<String, Reflections> REFLECTIONS_CACHE = new java.util.concurrent.ConcurrentHashMap<>();
 
     /**
      * 以默认配置的基础包路径获取反射器
@@ -47,52 +49,48 @@ public final class ReflectionUtil {
     }
 
     /**
-     * 获取反射器
+     * 获取反射器（带缓存）
      *
      * @param packageAddress Package address String
      * @return Reflections object
      */
     public static Reflections getReflections(String packageAddress) {
-        List<String> packageAddressList;
-        if (packageAddress.contains(",")) {
-            packageAddressList = Arrays.asList(packageAddress.split(","));
-        } else if (packageAddress.contains(";")) {
-            packageAddressList = Arrays.asList(packageAddress.split(";"));
-        } else {
-            packageAddressList = Collections.singletonList(packageAddress);
-        }
-
-        return getReflections(packageAddressList);
+        return REFLECTIONS_CACHE.computeIfAbsent(packageAddress, key -> {
+            List<String> packageAddressList;
+            if (key.contains(",")) {
+                packageAddressList = Arrays.asList(key.split(","));
+            } else if (key.contains(";")) {
+                packageAddressList = Arrays.asList(key.split(";"));
+            } else {
+                packageAddressList = Collections.singletonList(key);
+            }
+            return createReflections(packageAddressList);
+        });
     }
 
     /**
-     * 获取反射器
+     * 获取反射器（带缓存）
      *
      * @param packageAddresses Package address List
      * @return Reflections object
      */
     public static Reflections getReflections(List<String> packageAddresses) {
-        ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
-        FilterBuilder filterBuilder = new FilterBuilder();
-        packageAddresses.forEach(str -> {
-            Collection<URL> urls = ClasspathHelper.forPackage(str.trim());
-            configurationBuilder.addUrls(urls);
-            filterBuilder.includePackage(str.trim());
-        });
+        String cacheKey = String.join(",", packageAddresses);
+        return REFLECTIONS_CACHE.computeIfAbsent(cacheKey, key -> createReflections(packageAddresses));
+    }
 
-        // 采坑记录 2021-05-08
-        // 发现注解api层 没有继承父类时 这里反射一直有问题(Scanner SubTypesScanner was not configured)
-        // 因此这里需要手动配置各种Scanner扫描器 -- https://blog.csdn.net/qq_29499107/article/details/106889781
-        configurationBuilder.setScanners(
-                Scanners.SubTypes.filterResultsBy(s -> true), //允许getAllTypes获取所有Object的子类, 不设置为false则 getAllTypes
-                // 会报错.默认为true.
-                new MethodParameterNamesScanner(), //设置方法参数名称 扫描器,否则调用getConstructorParamNames 会报错
-                Scanners.MethodsAnnotated, //设置方法注解 扫描器, 否则getConstructorsAnnotatedWith,getMethodsAnnotatedWith 会报错
-                new MemberUsageScanner(),  //设置 member 扫描器,否则 getMethodUsage 会报错
-                Scanners.TypesAnnotated //设置类注解 扫描器 ,否则 getTypesAnnotatedWith 会报错
-        );
-
-        configurationBuilder.filterInputsBy(filterBuilder);
+    private static Reflections createReflections(List<String> packageAddresses) {
+        ConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
+                .addClassLoaders(Thread.currentThread().getContextClassLoader())
+                .forPackages(packageAddresses.toArray(new String[0]))
+                .setScanners(
+                        Scanners.SubTypes.filterResultsBy(s -> true), //允许getAllTypes获取所有Object的子类, 不设置为false则 getAllTypes
+                        // 会报错.默认为true.
+                        new MethodParameterNamesScanner(), //设置方法参数名称 扫描器,否则调用getConstructorParamNames 会报错
+                        Scanners.MethodsAnnotated, //设置方法注解 扫描器, 否则getConstructorsAnnotatedWith,getMethodsAnnotatedWith 会报错
+                        new MemberUsageScanner(),  //设置 member 扫描器,否则 getMethodUsage 会报错
+                        Scanners.TypesAnnotated //设置类注解 扫描器 ,否则 getTypesAnnotatedWith 会报错
+                );
         return new Reflections(configurationBuilder);
     }
 

core/src/main/java/cn/qaiu/vx/core/util/ResponseUtil.java

@@ -13,6 +13,7 @@ public class ResponseUtil {
 
     public static void redirect(HttpServerResponse response, String url) {
         response.putHeader(CONTENT_TYPE, "text/html; charset=utf-8")
+                .putHeader("Referrer-Policy", "no-referrer")
                 .putHeader(HttpHeaders.LOCATION, url).setStatusCode(302).end();
     }
 
@@ -22,14 +23,22 @@ public class ResponseUtil {
     }
 
     public static void fireJsonObjectResponse(RoutingContext ctx, JsonObject jsonObject) {
-        ctx.response().putHeader(CONTENT_TYPE, "application/json; charset=utf-8")
-                .setStatusCode(200)
-                .end(jsonObject.encode());
+        fireJsonObjectResponse(ctx, jsonObject, 200);
     }
 
     public static void fireJsonObjectResponse(HttpServerResponse ctx, JsonObject jsonObject) {
+        fireJsonObjectResponse(ctx, jsonObject, 200);
+    }
+
+    public static void fireJsonObjectResponse(RoutingContext ctx, JsonObject jsonObject, int statusCode) {
+        ctx.response().putHeader(CONTENT_TYPE, "application/json; charset=utf-8")
+                .setStatusCode(statusCode)
+                .end(jsonObject.encode());
+    }
+
+    public static void fireJsonObjectResponse(HttpServerResponse ctx, JsonObject jsonObject, int statusCode) {
         ctx.putHeader(CONTENT_TYPE, "application/json; charset=utf-8")
-                .setStatusCode(200)
+                .setStatusCode(statusCode)
                 .end(jsonObject.encode());
     }
 
@@ -37,6 +46,10 @@ public class ResponseUtil {
         fireJsonObjectResponse(ctx, jsonResult.toJsonObject());
     }
 
+    public static <T> void fireJsonResultResponse(RoutingContext ctx, JsonResult<T> jsonResult, int statusCode) {
+        fireJsonObjectResponse(ctx, jsonResult.toJsonObject(), statusCode);
+    }
+
     public static <T> void fireJsonResultResponse(HttpServerResponse ctx, JsonResult<T> jsonResult) {
         fireJsonObjectResponse(ctx, jsonResult.toJsonObject());
     }

core/src/main/java/cn/qaiu/vx/core/verticle/HttpProxyVerticle.java

@@ -1,50 +1,77 @@
 package cn.qaiu.vx.core.verticle;
 
 import io.vertx.core.AbstractVerticle;
-import io.vertx.core.Vertx;
-import io.vertx.core.VertxOptions;
-import io.vertx.core.dns.AddressResolverOptions;
 import io.vertx.core.http.*;
+import io.vertx.core.json.JsonObject;
 import io.vertx.core.net.NetClient;
 import io.vertx.core.net.NetClientOptions;
-import io.vertx.core.net.NetSocket;
 import io.vertx.core.net.ProxyOptions;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.net.URI;
 import java.util.Base64;
 
+import static cn.qaiu.vx.core.util.ConfigConstant.GLOBAL_CONFIG;
+import static cn.qaiu.vx.core.util.ConfigConstant.LOCAL;
+
 /**
  *
  */
 public class HttpProxyVerticle extends AbstractVerticle {
+    private static final Logger LOGGER = LoggerFactory.getLogger(HttpProxyVerticle.class);
 
     private HttpClient httpClient;
     private NetClient netClient;
 
+    private JsonObject proxyPreConf;
+    private JsonObject proxyServerConf;
+
+
     @Override
     public void start() {
-        ProxyOptions proxyOptions = new ProxyOptions().setHost("127.0.0.1").setPort(7890);
+        proxyServerConf = ((JsonObject)vertx.sharedData().getLocalMap(LOCAL).get(GLOBAL_CONFIG)).getJsonObject("proxy-server");
+        proxyPreConf = ((JsonObject)vertx.sharedData().getLocalMap(LOCAL).get(GLOBAL_CONFIG)).getJsonObject("proxy-pre");
+        Integer serverPort = proxyServerConf.getInteger("port");
+
+        ProxyOptions proxyOptions = null;
+        if (proxyPreConf != null && StringUtils.isNotBlank(proxyPreConf.getString("ip"))) {
+            proxyOptions = new ProxyOptions(proxyPreConf);
+        }
+
         // 初始化 HTTP 客户端，用于向目标服务器发送 HTTP 请求
         HttpClientOptions httpClientOptions = new HttpClientOptions();
-        httpClient = vertx.createHttpClient(httpClientOptions.setProxyOptions(proxyOptions));
+        if (proxyOptions != null) {
+            httpClientOptions.setProxyOptions(proxyOptions);
+        }
+        httpClient = vertx.createHttpClient(httpClientOptions);
 
         // 创建并启动 HTTP 代理服务器，监听指定端口
-        HttpServer server = vertx.createHttpServer(new HttpServerOptions().setClientAuth(ClientAuth.REQUIRED));
+        HttpServerOptions httpServerOptions = new HttpServerOptions();
+        if (proxyServerConf.containsKey("username") &&
+                StringUtils.isNotBlank(proxyServerConf.getString("username"))) {
+            httpServerOptions.setClientAuth(ClientAuth.REQUIRED);
+        }
+
+        HttpServer server = vertx.createHttpServer();
         server.requestHandler(this::handleClientRequest);
 
         // 初始化 NetClient，用于在 CONNECT 请求中建立 TCP 连接隧道
-        netClient = vertx.createNetClient(new NetClientOptions()
-                .setProxyOptions(proxyOptions)
+        NetClientOptions netClientOptions = new NetClientOptions();
+
+        if (proxyOptions != null) {
+            httpClientOptions.setProxyOptions(proxyOptions);
+        }
+
+        netClient = vertx.createNetClient(netClientOptions
                 .setConnectTimeout(15000)
                 .setTrustAll(true));
 
         // 启动 HTTP 代理服务器
-        server.listen(7891, ar -> {
-            if (ar.succeeded()) {
-                System.out.println("HTTP Proxy server started on port 7891");
-            } else {
-                System.err.println("Failed to start HTTP Proxy server: " + ar.cause());
-            }
-        });
+        server.listen(serverPort)
+                .onSuccess(res-> LOGGER.info("HTTP Proxy server started on port {}", serverPort))
+                .onFailure(err-> LOGGER.error("Failed to start HTTP Proxy server: " + err.getMessage()));
     }
 
     // 处理 HTTP CONNECT 请求，用于代理 HTTPS 流量
@@ -66,49 +93,54 @@ public class HttpProxyVerticle extends AbstractVerticle {
         }
         clientRequest.pause();
         // 通过 NetClient 连接目标服务器并创建隧道
-        netClient.connect(targetPort, targetHost, connectionAttempt -> {
-            if (connectionAttempt.succeeded()) {
-                NetSocket targetSocket = connectionAttempt.result();
+        netClient.connect(targetPort, targetHost)
+                .onSuccess(targetSocket -> {
+                    // Upgrade client connection to NetSocket and implement bidirectional data flow
+                    clientRequest.toNetSocket()
+                            .onSuccess(clientSocket -> {
+                                // Set up bidirectional data forwarding
+                                clientSocket.handler(targetSocket::write);
+                                targetSocket.handler(clientSocket::write);
 
-                // 升级客户端连接到 NetSocket 并实现双向数据流
-                clientRequest.toNetSocket().onComplete(clientSocketAttempt -> {
-                    if (clientSocketAttempt.succeeded()) {
-                        NetSocket clientSocket = clientSocketAttempt.result();
-
-                        // 设置双向数据流转发
-                        clientSocket.handler(targetSocket::write);
-                        targetSocket.handler(clientSocket::write);
-
-                        // 关闭其中一方时关闭另一方
-                        clientSocket.closeHandler(v -> targetSocket.close());
-                        targetSocket.closeHandler(v -> clientSocket.close());
-                    } else {
-                        System.err.println("Failed to upgrade client connection to socket: " + clientSocketAttempt.cause().getMessage());
-                        targetSocket.close();
-                        clientRequest.response().setStatusCode(500).end("Internal Server Error");
-                    }
+                                // Close the other socket when one side closes
+                                clientSocket.closeHandler(v -> targetSocket.close());
+                                targetSocket.closeHandler(v -> clientSocket.close());
+                            })
+                            .onFailure(clientSocketAttempt -> {
+                                System.err.println("Failed to upgrade client connection to socket: " + clientSocketAttempt.getMessage());
+                                targetSocket.close();
+                                clientRequest.response().setStatusCode(500).end("Internal Server Error");
+                            });
+                })
+                .onFailure(connectionAttempt -> {
+                    System.err.println("Failed to connect to target: " + connectionAttempt.getMessage());
+                    clientRequest.response().setStatusCode(502).end("Bad Gateway: Unable to connect to target");
                 });
-            } else {
-                System.err.println("Failed to connect to target: " + connectionAttempt.cause().getMessage());
-                clientRequest.response().setStatusCode(502).end("Bad Gateway: Unable to connect to target");
-            }
-        });
     }
 
     // 处理客户端的 HTTP 请求
     private void handleClientRequest(HttpServerRequest clientRequest) {
-        String s = clientRequest.headers().get("Proxy-Authorization");
-        if (s == null) {
-            clientRequest.response().setStatusCode(403).end();
-            return;
+        // 打印来源ip和访问目标URI
+        LOGGER.debug("source: {}, target: {}", clientRequest.remoteAddress().toString(), clientRequest.uri());
+        if (proxyServerConf.containsKey("username") &&
+                StringUtils.isNotBlank(proxyServerConf.getString("username"))) {
+            String s = clientRequest.headers().get("Proxy-Authorization");
+            if (s == null) {
+                clientRequest.response().setStatusCode(403).end();
+                return;
+            }
+            String[] split = new String(Base64.getDecoder().decode(s.replace("Basic ", ""))).split(":");
+            if (split.length > 1) {
+                // TODO
+                String username = proxyServerConf.getString("username");
+                String password = proxyServerConf.getString("password");
+                if (!split[0].equals(username) || !split[1].equals(password)) {
+                    LOGGER.info("-----auth failed------\nusername: {}\npassword: {}", username, password);
+                    clientRequest.response().setStatusCode(403).end();
+                    return;
+                }
+            }
         }
-        String[] split = new String(Base64.getDecoder().decode(s.replace("Basic ", ""))).split(":");
-        if (split.length > 1) {
-            System.out.println(split[0]);
-            System.out.println(split[1]);
-            // TODO
-        }
-
 
         if (clientRequest.method() == HttpMethod.CONNECT) {
             // 处理 CONNECT 请求
@@ -129,7 +161,7 @@ public class HttpProxyVerticle extends AbstractVerticle {
         }
 
         String targetHost = hostHeader.split(":")[0];
-        int targetPort = 80; // 默认为 HTTP 的端口
+        int targetPort = extractPortFromUrl(clientRequest.uri()); // 默认为 HTTP 的端口
         clientRequest.pause(); // 暂停客户端请求的读取，避免数据丢失
 
         httpClient.request(clientRequest.method(), targetPort, targetHost, clientRequest.uri())
@@ -140,16 +172,19 @@ public class HttpProxyVerticle extends AbstractVerticle {
                     clientRequest.headers().forEach(header -> request.putHeader(header.getKey(), header.getValue()));
 
                     // 将客户端请求的 body 转发给目标服务器
-                    clientRequest.bodyHandler(body -> request.send(body, ar -> {
-                        if (ar.succeeded()) {
-                            var response = ar.result();
-                            clientRequest.response().setStatusCode(response.statusCode());
-                            clientRequest.response().headers().setAll(response.headers());
-                            response.body().onSuccess(b-> clientRequest.response().end(b));
-                        } else {
-                            clientRequest.response().setStatusCode(502).end("Bad Gateway: Unable to reach target");
-                        }
-                    }));
+                    clientRequest.bodyHandler(body ->
+                            request.send(body)
+                                    .onSuccess(response -> {
+                                        clientRequest.response().setStatusCode(response.statusCode());
+                                        clientRequest.response().headers().setAll(response.headers());
+                                        response.body()
+                                                .onSuccess(b -> clientRequest.response().end(b))
+                                                .onFailure(err -> clientRequest.response()
+                                                        .setStatusCode(502).end("Bad Gateway: Unable to reach target"));
+                                    })
+                                    .onFailure(err -> clientRequest.response()
+                                            .setStatusCode(502).end("Bad Gateway: Unable to reach target"))
+                    );
                 })
                 .onFailure(err -> {
                     err.printStackTrace();
@@ -157,28 +192,43 @@ public class HttpProxyVerticle extends AbstractVerticle {
                 });
     }
 
+
+    /**
+     * 从 URL 中提取端口号
+     *
+     * @param urlString URL 字符串
+     * @return 提取的端口号，如果没有指定端口，则返回默认端口
+     */
+    public static int extractPortFromUrl(String urlString) {
+        try {
+            URI uri = new URI(urlString);
+            int port = uri.getPort();
+            // 如果 URL 没有指定端口，使用默认端口
+            if (port == -1) {
+                if ("https".equalsIgnoreCase(uri.getScheme())) {
+                    port = 443; // HTTPS 默认端口
+                } else {
+                    port = 80; // HTTP 默认端口
+                }
+            }
+            return port;
+        } catch (Exception e) {
+            e.printStackTrace();
+            // 出现异常时返回 -1，表示提取失败
+            return -1;
+        }
+    }
+
+
     @Override
     public void stop() {
         // 停止 HTTP 客户端以释放资源
         if (httpClient != null) {
             httpClient.close();
         }
+        if (netClient != null) {
+            netClient.close();
+        }
     }
 
-    /**
-     * TODO add Deploy
-     * @param args
-     */
-    public static void main(String[] args) {
-        // 配置 DNS 解析器，使用多个 DNS 服务器来提升解析速度
-        Vertx vertx = Vertx.vertx(new VertxOptions()
-                .setAddressResolverOptions(new AddressResolverOptions()
-                        .addServer("114.114.114.114")
-                        .addServer("114.114.115.115")
-                        .addServer("8.8.8.8")
-                        .addServer("8.8.4.4")));
-
-        // 部署 Verticle 并启动动态 HTTP 代理服务器
-        vertx.deployVerticle(new HttpProxyVerticle());
-    }
 }

core/src/main/java/cn/qaiu/vx/core/verticle/PostExecVerticle.java

@@ -0,0 +1,68 @@
+package cn.qaiu.vx.core.verticle;
+
+import cn.qaiu.vx.core.base.AppRun;
+import cn.qaiu.vx.core.base.DefaultAppRun;
+import cn.qaiu.vx.core.util.CommonUtil;
+import cn.qaiu.vx.core.util.ReflectionUtil;
+import cn.qaiu.vx.core.util.SharedDataUtil;
+import io.vertx.core.AbstractVerticle;
+import io.vertx.core.Promise;
+import io.vertx.core.json.JsonObject;
+import org.reflections.Reflections;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 后置执行Verticle - 在core启动后立即执行AppRun实现
+ * <br>Create date 2024-01-01 00:00:00
+ *
+ * @author <a href="https://qaiu.top">QAIU</a>
+ */
+public class PostExecVerticle extends AbstractVerticle {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PostExecVerticle.class);
+    private static final Set<AppRun> appRunImplementations;
+    private static final AtomicBoolean lock = new AtomicBoolean(false);
+
+    static {
+        Reflections reflections = ReflectionUtil.getReflections();
+        Set<Class<? extends AppRun>> subTypesOf = reflections.getSubTypesOf(AppRun.class);
+        subTypesOf.add(DefaultAppRun.class);
+        appRunImplementations = CommonUtil.sortClassSet(subTypesOf);
+        if (appRunImplementations.isEmpty()) {
+            LOGGER.warn("未找到 AppRun 接口的实现类");
+        } else {
+            LOGGER.info("找到 {} 个 AppRun 接口的实现类", appRunImplementations.size());
+        }
+    }
+
+    @Override
+    public void start(Promise<Void> startPromise) {
+        if (!lock.compareAndSet(false, true)) {
+            return;
+        }
+        LOGGER.info("PostExecVerticle 开始执行...");
+        
+        if (appRunImplementations != null && !appRunImplementations.isEmpty()) {
+            appRunImplementations.forEach(appRun -> {
+                try {
+                    LOGGER.info("执行 AppRun 实现: {}", appRun.getClass().getName());
+                    JsonObject globalConfig = SharedDataUtil.getJsonConfig("globalConfig");
+                    appRun.execute(globalConfig);
+                    LOGGER.info("AppRun 实现 {} 执行完成", appRun.getClass().getName());
+                } catch (Exception e) {
+                    LOGGER.error("执行 AppRun 实现 {} 时发生错误",appRun.getClass().getName(), e);
+                }
+            });
+        } else {
+            LOGGER.info("未找到 AppRun 接口的实现类");
+        }
+        
+        LOGGER.info("PostExecVerticle 执行完成");
+        startPromise.complete();
+    }
+}

core/src/main/java/cn/qaiu/vx/core/verticle/ReverseProxyVerticle.java

@@ -5,8 +5,10 @@ import io.vertx.core.AbstractVerticle;
 import io.vertx.core.Future;
 import io.vertx.core.Promise;
 import io.vertx.core.http.HttpClient;
+import io.vertx.core.http.HttpClientOptions;
 import io.vertx.core.http.HttpServer;
 import io.vertx.core.http.HttpServerOptions;
+import io.vertx.core.http.HttpServerRequest;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.net.PemKeyCertOptions;
@@ -15,6 +17,9 @@ import io.vertx.ext.web.Router;
 import io.vertx.ext.web.handler.StaticHandler;
 import io.vertx.ext.web.proxy.handler.ProxyHandler;
 import io.vertx.httpproxy.HttpProxy;
+import io.vertx.httpproxy.ProxyContext;
+import io.vertx.httpproxy.ProxyInterceptor;
+import io.vertx.httpproxy.ProxyResponse;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -22,12 +27,16 @@ import org.slf4j.LoggerFactory;
 import java.io.File;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * <p>反向代理服务</p>
  * <p>可以根据配置文件自动生成代理服务</p>
  * <p>可以配置多个服务, 配置文件见示例</p>
+ * <p>【优化】支持高并发场景，连接池复用，避免线程阻塞</p>
  * <br>Create date 2021/9/2 0:41
  *
  * @author <a href="https://qaiu.top">QAIU</a>
@@ -46,14 +55,83 @@ public class ReverseProxyVerticle extends AbstractVerticle {
 
     public static String REROUTE_PATH_PREFIX = "/__rrvpspp"; //re_route_vert_proxy_server_path_prefix 硬编码
 
+    /**
+     * 【优化】HttpClient连接池，按host:port缓存复用，避免每个请求都创建新连接
+     */
+    private final Map<String, HttpClient> httpClientPool = new ConcurrentHashMap<>();
+
+    /**
+     * 【优化】高并发场景下的HttpClient配置
+     */
+    private static final int MAX_POOL_SIZE = 100;           // 最大连接池大小
+    private static final int MAX_WAIT_QUEUE_SIZE = 500;    // 最大等待队列大小
+    private static final int CONNECT_TIMEOUT = 30000;      // 连接超时30秒
+    private static final int IDLE_TIMEOUT = 60;            // 空闲超时60秒
+    private static final boolean KEEP_ALIVE = true;        // 启用Keep-Alive
+    private static final boolean PIPELINING = true;        // 启用HTTP管线化
+
 
     @Override
     public void start(Promise<Void> startPromise) {
-        CONFIG.onSuccess(this::handleProxyConfList);
+        CONFIG.onSuccess(this::handleProxyConfList).onFailure(e -> {
+            LOGGER.info("web代理配置已禁用，当前仅支持API调用");
+        });
 //        createFileListener
         startPromise.complete();
     }
 
+    /**
+     * 【优化】Verticle停止时清理HttpClient连接池
+     */
+    @Override
+    public void stop(Promise<Void> stopPromise) {
+        LOGGER.info("Stopping ReverseProxyVerticle, closing {} HttpClient connections...", httpClientPool.size());
+        httpClientPool.values().forEach(client -> {
+            try {
+                client.close();
+            } catch (Exception e) {
+                LOGGER.warn("Error closing HttpClient: {}", e.getMessage());
+            }
+        });
+        httpClientPool.clear();
+        stopPromise.complete();
+    }
+
+    /**
+     * 【优化】获取或创建HttpClient，实现连接池复用
+     * @param host 目标主机
+     * @param port 目标端口
+     * @return HttpClient实例
+     */
+    private HttpClient getOrCreateHttpClient(String host, int port) {
+        String key = host + ":" + port;
+        return httpClientPool.computeIfAbsent(key, k -> {
+            LOGGER.info("Creating new HttpClient for {}", key);
+            HttpClientOptions options = new HttpClientOptions()
+                    .setMaxPoolSize(MAX_POOL_SIZE)                    // 连接池大小
+                    .setMaxWaitQueueSize(MAX_WAIT_QUEUE_SIZE)         // 等待队列大小
+                    .setConnectTimeout(CONNECT_TIMEOUT)               // 连接超时
+                    .setIdleTimeout(IDLE_TIMEOUT)                     // 空闲超时
+                    .setKeepAlive(KEEP_ALIVE)                         // Keep-Alive
+                    .setKeepAliveTimeout(120)                         // Keep-Alive超时120秒
+                    .setPipelining(PIPELINING)                        // HTTP管线化
+                    .setPipeliningLimit(10)                           // 管线化限制
+                    .setDecompressionSupported(true)                  // 支持解压响应
+                    .setTcpKeepAlive(true)                            // TCP Keep-Alive
+                    .setTcpNoDelay(true)                              // 禁用Nagle算法，降低延迟
+                    .setTcpFastOpen(true)                             // 启用TCP Fast Open
+                    .setTcpQuickAck(true)                             // 启用TCP Quick ACK
+                    .setReuseAddress(true)                            // 允许地址重用
+                    .setReusePort(true);                              // 允许端口重用
+            return vertx.createHttpClient(options);
+        });
+    }
+
+    /**
+     * 全局可信上游代理 IP 集合（如 nginx），仅这些 IP 的 X-Forwarded-For 会被信任
+     */
+    private Set<String> globalTrustedProxies = new HashSet<>();
+
     /**
      * 获取主配置文件
      *
@@ -61,6 +139,15 @@ public class ReverseProxyVerticle extends AbstractVerticle {
      */
     private void handleProxyConfList(JsonObject config) {
         serverName = config.getString("server-name");
+        // 解析全局 trusted-proxies
+        JsonArray trustedArr = config.getJsonArray("trusted-proxies");
+        if (trustedArr != null) {
+            trustedArr.forEach(ip -> {
+                if (ip instanceof String) {
+                    globalTrustedProxies.add(((String) ip).trim());
+                }
+            });
+        }
         JsonArray proxyConfList = config.getJsonArray("proxy");
         if (proxyConfList != null) {
             proxyConfList.forEach(proxyConf -> {
@@ -71,6 +158,44 @@ public class ReverseProxyVerticle extends AbstractVerticle {
         }
     }
 
+    /**
+     * 解析真实客户端 IP。
+     * 若直连来源在可信代理列表中，优先取 X-Real-IP，其次取 X-Forwarded-For 第一个值；
+     * 否则直接使用直连对端地址。
+     */
+    private String resolveClientIp(HttpServerRequest request) {
+        String peerIp = request.remoteAddress().host();
+        if (globalTrustedProxies.contains(peerIp)) {
+            String realIp = request.getHeader("X-Real-IP");
+            if (StringUtils.isNotBlank(realIp)) {
+                return realIp.trim();
+            }
+            String xff = request.getHeader("X-Forwarded-For");
+            if (StringUtils.isNotBlank(xff)) {
+                return xff.split(",")[0].trim();
+            }
+        }
+        return peerIp;
+    }
+
+    /**
+     * 解析 proxy-set-headers 中的 nginx 风格变量。
+     * 支持：$remote_addr、$proxy_add_x_forwarded_for、$scheme、$host；
+     * 其他值作为字面量直接使用。
+     */
+    private String resolveHeaderVariable(String tpl, HttpServerRequest req, String clientIp) {
+        return switch (tpl) {
+            case "$remote_addr" -> clientIp;
+            case "$proxy_add_x_forwarded_for" -> {
+                String existing = req.getHeader("X-Forwarded-For");
+                yield StringUtils.isNotBlank(existing) ? existing + ", " + clientIp : clientIp;
+            }
+            case "$scheme" -> req.isSSL() ? "https" : "http";
+            case "$host"   -> req.getHeader("Host");
+            default        -> tpl;
+        };
+    }
+
     /**
      * 处理单个反向代理配置
      *
@@ -97,18 +222,25 @@ public class ReverseProxyVerticle extends AbstractVerticle {
             proxyConf.put("page404", DEFAULT_PATH_404);
         }
 
-        final HttpClient httpClient = VertxHolder.getVertxInstance().createHttpClient();
         Router proxyRouter = Router.router(vertx);
 
         // Add Server name header
         proxyRouter.route().handler(ctx -> {
+            String realPath = ctx.request().uri();
+            if (realPath.startsWith(REROUTE_PATH_PREFIX)) {
+                // vertx web proxy暂不支持rewrite, 所以这里进行手动替换, 请求地址中的请求path前缀替换为originPath
+                String rePath = realPath.replace(REROUTE_PATH_PREFIX, "");
+                ctx.reroute(rePath);
+                return;
+            }
+
             ctx.response().putHeader("Server", serverName);
             ctx.next();
         });
 
         // http api proxy
         if (proxyConf.containsKey("location")) {
-            handleLocation(proxyConf.getJsonArray("location"), httpClient, proxyRouter);
+            handleLocation(proxyConf.getJsonArray("location"), proxyRouter);
         }
 
         // static server
@@ -117,7 +249,9 @@ public class ReverseProxyVerticle extends AbstractVerticle {
         }
 
         // Send page404 page
-        proxyRouter.errorHandler(404, ctx -> ctx.response().sendFile(proxyConf.getString("page404")));
+        proxyRouter.errorHandler(404, ctx -> {
+            ctx.response().sendFile(proxyConf.getString("page404"));
+        });
 
         HttpServer server = getHttpsServer(proxyConf);
         server.requestHandler(proxyRouter);
@@ -129,8 +263,16 @@ public class ReverseProxyVerticle extends AbstractVerticle {
 
     private HttpServer getHttpsServer(JsonObject proxyConf) {
         HttpServerOptions httpServerOptions = new HttpServerOptions()
-        .setCompressionSupported(true);
-
+                // 【优化】高并发服务器配置
+                .setTcpKeepAlive(true)                    // TCP Keep-Alive
+                .setTcpNoDelay(true)                      // 禁用Nagle算法
+                .setCompressionSupported(true)            // 启用压缩
+                .setAcceptBacklog(50000)                  // 增加积压队列到50000
+                .setIdleTimeout(120)                      // 空闲超时120秒
+                .setTcpFastOpen(true)                     // 启用TCP Fast Open
+                .setTcpQuickAck(true)                     // 启用TCP Quick ACK
+                .setReuseAddress(true)                    // 允许地址重用
+                .setReusePort(true);                      // 允许端口重用
         if (proxyConf.containsKey("ssl")) {
             JsonObject sslConfig = proxyConf.getJsonObject("ssl");
 
@@ -184,7 +326,6 @@ public class ReverseProxyVerticle extends AbstractVerticle {
         } else {
             staticHandler = StaticHandler.create();
         }
-        
         if (staticConf.containsKey("directory-listing")) {
             staticHandler.setDirectoryListing(staticConf.getBoolean("directory-listing"));
         } else if (staticConf.containsKey("index")) {
@@ -197,10 +338,9 @@ public class ReverseProxyVerticle extends AbstractVerticle {
      * 处理Location配置 代理请求Location(和nginx类似?)
      *
      * @param locationsConf location配置
-     * @param httpClient    客户端
      * @param proxyRouter   代理路由
      */
-    private void handleLocation(JsonArray locationsConf, HttpClient httpClient, Router proxyRouter) {
+    private void handleLocation(JsonArray locationsConf, Router proxyRouter) {
 
         locationsConf.stream().map(e -> (JsonObject) e).forEach(location -> {
             // 代理规则
@@ -216,9 +356,33 @@ public class ReverseProxyVerticle extends AbstractVerticle {
                 String originPath = url.getPath();
                 LOGGER.info("path {}, originPath {}, to {}:{}", path, originPath, host, port);
 
-                // 注意这里不能origin多个代理地址, 一个实例只能代理一个origin
+                // 【优化】使用连接池获取HttpClient，避免每个location都创建新连接
+                final HttpClient httpClient = getOrCreateHttpClient(host, port);
                 final HttpProxy httpProxy = HttpProxy.reverseProxy(httpClient);
                 httpProxy.origin(port, host);
+
+                // proxy-set-headers 支持（nginx 风格变量替换）
+                if (location.containsKey("proxy-set-headers")) {
+                    final JsonObject headerConf = location.getJsonObject("proxy-set-headers");
+                    httpProxy.addInterceptor(new ProxyInterceptor() {
+                        @Override
+                        public Future<ProxyResponse> handleProxyRequest(ProxyContext ctx) {
+                            HttpServerRequest incoming = ctx.request().proxiedRequest();
+                            String clientIp = resolveClientIp(incoming);
+                            headerConf.forEach(entry -> {
+                                Object val = entry.getValue();
+                                if (val != null) {
+                                    String resolved = resolveHeaderVariable(val.toString(), incoming, clientIp);
+                                    if (resolved != null) {
+                                        ctx.request().putHeader(entry.getKey(), resolved);
+                                    }
+                                }
+                            });
+                            return ProxyInterceptor.super.handleProxyRequest(ctx);
+                        }
+                    });
+                }
+
                 if (StringUtils.isEmpty(path)) {
                     return;
                 }
@@ -227,24 +391,65 @@ public class ReverseProxyVerticle extends AbstractVerticle {
                 if (StringUtils.isEmpty(originPath) || path.equals(originPath)) {
                     Route route = path.startsWith("~") ? proxyRouter.routeWithRegex(path.substring(1))
                             : proxyRouter.route(path);
+                    // 【优化】为代理处理器添加超时
                     route.handler(ProxyHandler.create(httpProxy));
                 } else {
                     // 配置 /api/, / => 请求 /api/test 代理后 /test
                     // 配置 /api/, /xxx => 请求 /api/test 代理后 /xxx/test
-                    final String path0 = path;
-                    final String originPath0 = REROUTE_PATH_PREFIX + originPath;
+                     final String path0 = path;
+                     final String originPath0 = REROUTE_PATH_PREFIX + originPath;
 
-                    proxyRouter.route(originPath0 + "*").handler(ProxyHandler.create(httpProxy));
-                    proxyRouter.route(path0 + "*").handler(ctx -> {
-                        String realPath = ctx.request().uri();
-                        if (realPath.startsWith(path0)) {
-                            // vertx web proxy暂不支持rewrite, 所以这里进行手动替换, 请求地址中的请求path前缀替换为originPath
-                            String rePath = realPath.replaceAll("^" + path0, originPath0);
-                            ctx.reroute(rePath);
-                        } else {
-                            ctx.next();
-                        }
-                    });
+                     proxyRouter.route(originPath0 + "*").handler(ProxyHandler.create(httpProxy));
+                     proxyRouter.route(path0 + "*").handler(ctx -> {
+                         String realPath = ctx.request().uri();
+                         if (realPath.startsWith(path0)) {
+                             // vertx web proxy暂不支持rewrite, 所以这里进行手动替换, 请求地址中的请求path前缀替换为originPath
+                             String rePath = realPath.replaceAll("^" + path0, originPath0);
+                             ctx.reroute(rePath);
+                         } else {
+                             ctx.next();
+                         }
+                     });
+                    // 计算唯一后缀，避免多个 location 冲突
+//                    String uniqueKey = (host + ":" + port + "|" + path).replaceAll("[^a-zA-Z0-9:_|/]", "");
+//                    String uniqueSuffix = Integer.toHexString(uniqueKey.hashCode());
+//
+//// 规格化 originPath
+//                    //String originPath = url.getPath(); // 原值
+//                    if (StringUtils.isBlank(originPath)) originPath = "/";
+//
+//// 处理 index.html 的情况：用于首页兜底，其它子路径仍按目录穿透
+//                    String indexFile;
+//                    if (originPath.endsWith(".html")) {
+//                        indexFile = originPath;     // 例如 /index.html
+//                        originPath = "/";           // 目录穿透基准改为根
+//                    } else {
+//                        indexFile = null;
+//                    }
+//
+//// 唯一内部挂载前缀
+//                    final String originMount = REROUTE_PATH_PREFIX + uniqueSuffix + originPath;
+//
+//// 1) 目标挂载：所有被重写的请求最终到这里走 ProxyHandler
+//                    proxyRouter.route(originMount + "*").handler(ProxyHandler.create(httpProxy));
+//
+//// 2) 从外部前缀 -> 内部挂载 的重写
+//                    final String path0 = path;
+//                    proxyRouter.route(path0 + "*").handler(ctx -> {
+//                        String uri = ctx.request().uri();
+//                        if (!uri.startsWith(path0)) { ctx.next(); return; }
+//
+//                        // 首页兜底：访问 /n2 或 /n2/ 时，重写到 index.html（如果配置了）
+//                        if (indexFile != null && (uri.equals(path0) || uri.equals(path0.substring(0, path0.length()-1)))) {
+//                            String rePath = originMount.endsWith("/") ? (originMount + indexFile.substring(1)) : (originMount + indexFile);
+//                            ctx.reroute(rePath);
+//                            return;
+//                        }
+//
+//                        // 一般穿透：/n2/xxx -> originMount + xxx
+//                        String rePath = uri.replaceFirst("^" + path0, originMount);
+//                        ctx.reroute(rePath);
+//                    });
                 }
 
             } catch (MalformedURLException e) {

core/src/main/java/cn/qaiu/vx/core/verticle/RouterVerticle.java

@@ -49,6 +49,18 @@ public class RouterVerticle extends AbstractVerticle {
             options = new HttpServerOptions();
         }
         options.setPort(port);
+        
+        // 【优化】高并发服务器配置
+        options.setTcpKeepAlive(true)                     // TCP Keep-Alive
+               .setTcpNoDelay(true)                       // 禁用Nagle算法，降低延迟
+               .setCompressionSupported(true)             // 启用压缩
+               .setAcceptBacklog(50000)                   // 增加积压队列到50000，防止高并发时连接被拒绝
+               .setIdleTimeout(120)                       // 空闲超时120秒
+               .setTcpFastOpen(true)                      // 启用TCP Fast Open
+               .setTcpQuickAck(true)                      // 启用TCP Quick ACK
+               .setReuseAddress(true)                     // 允许地址重用
+               .setReusePort(true);                       // 允许端口重用
+        
         server = vertx.createHttpServer(options);
 
         server.requestHandler(router).webSocketHandler(s->{}).listen()

core/src/main/java/cn/qaiu/vx/core/verticle/ServiceVerticle.java

@@ -29,20 +29,23 @@ public class ServiceVerticle extends AbstractVerticle {
         Reflections reflections = ReflectionUtil.getReflections();
         handlers = reflections.getTypesAnnotatedWith(Service.class);
     }
-
     @Override
     public void start(Promise<Void> startPromise) {
         ServiceBinder binder = new ServiceBinder(vertx);
         if (null != handlers && handlers.size() > 0) {
+            // handlers转为拼接类列表，xxx,yyy,zzz
+            StringBuilder serviceNames = new StringBuilder();
             handlers.forEach(asyncService -> {
                 try {
+                    serviceNames.append(asyncService.getName()).append("|");
                     BaseAsyncService asInstance = (BaseAsyncService) ReflectionUtil.newWithNoParam(asyncService);
                     binder.setAddress(asInstance.getAddress()).register(asInstance.getAsyncInterfaceClass(), asInstance);
                 } catch (Exception e) {
-                    LOGGER.error(e.getMessage());
+                    LOGGER.error("Failed to register service: {}", asyncService.getName(), e);
                 }
             });
-            LOGGER.info("registered async services -> id: {}", ID.getAndIncrement());
+
+            LOGGER.info("registered async services -> id: {}, name: {}", ID.getAndIncrement(), serviceNames.toString());
         }
         startPromise.complete();
     }

core/src/main/java/cn/qaiu/vx/core/verticle/conf/HttpProxyConf.java

@@ -8,14 +8,14 @@ import io.vertx.core.net.ProxyOptions;
 import java.util.UUID;
 
 @DataObject
-@JsonGen(publicConverter = false)
+//@JsonGen(publicConverter = false)
 public class HttpProxyConf {
 
     public static final String DEFAULT_USERNAME = UUID.randomUUID().toString();
 
     public static final String DEFAULT_PASSWORD = UUID.randomUUID().toString();
 
-    public static final Integer DEFAULT_PORT = 6402;
+    public static final Integer DEFAULT_PORT = 6432;
 
     public static final Integer DEFAULT_TIMEOUT = 15000;
 

core/src/test/java/cn/qaiu/vx/core/test/JsonBodyBindingLogicTest.java

@@ -0,0 +1,134 @@
+package cn.qaiu.vx.core.test;
+
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * 单元测试：验证 RouterHandlerFactory 关于 JsonObject/JsonArray 参数绑定的核心分支逻辑是否正确
+ * （不启动整个 Vert.x 服务器，直接用 Vert.x JsonObject/JsonArray API 模拟验证关键逻辑）
+ */
+public class JsonBodyBindingLogicTest {
+
+    // === 模拟 handlerMethod 中的 JSON body 绑定逻辑 ===
+
+    /**
+     * 模拟：content-type = application/json，body 是 JsonObject
+     * 期望：JsonObject 类型参数被正确绑定
+     */
+    @Test
+    public void testJsonObjectBinding() {
+        String bodyStr = "{\"name\":\"test\",\"value\":123}";
+
+        // 模拟 ctx.body().asJsonObject()
+        JsonObject body = parseAsJsonObject(bodyStr);
+        Assert.assertNotNull("body 应能解析为 JsonObject", body);
+
+        // 模拟绑定逻辑中的类型判断
+        String targetType = JsonObject.class.getName();
+        boolean matched = JsonObject.class.getName().equals(targetType);
+        Assert.assertTrue("JsonObject 类型应命中绑定分支", matched);
+
+        // 模拟结果
+        Object bound = body; // parameterValueList.put(k, body)
+        Assert.assertNotNull("JsonObject 参数应被绑定（非null）", bound);
+        Assert.assertEquals("name字段应为test", "test", ((JsonObject) bound).getString("name"));
+        Assert.assertEquals("value字段应为123", 123, (int) ((JsonObject) bound).getInteger("value"));
+
+        System.out.println("[PASS] testJsonObjectBinding: JsonObject 绑定成功 -> " + bound);
+    }
+
+    /**
+     * 模拟：content-type = application/json，body 是 JsonArray
+     * 期望：JsonArray 类型参数被正确绑定
+     */
+    @Test
+    public void testJsonArrayBinding() {
+        String bodyStr = "[1,2,3]";
+
+        // body 解析为 JsonObject 应返回 null
+        JsonObject bodyAsObj = parseAsJsonObject(bodyStr);
+        Assert.assertNull("JsonArray body 解析为 JsonObject 应为 null", bodyAsObj);
+
+        // 进入 else 分支，解析为 JsonArray
+        JsonArray bodyArr = parseAsJsonArray(bodyStr);
+        Assert.assertNotNull("body 应能解析为 JsonArray", bodyArr);
+
+        String targetType = JsonArray.class.getName();
+        boolean matched = JsonArray.class.getName().equals(targetType);
+        Assert.assertTrue("JsonArray 类型应命中绑定分支", matched);
+
+        Object bound = bodyArr;
+        Assert.assertNotNull("JsonArray 参数应被绑定（非null）", bound);
+        Assert.assertEquals("数组大小应为3", 3, ((JsonArray) bound).size());
+
+        System.out.println("[PASS] testJsonArrayBinding: JsonArray 绑定成功, size=" + ((JsonArray) bound).size());
+    }
+
+    /**
+     * 验证旧代码的 bug：条件 ctx.body().asJsonObject() != null 会把 JsonArray body 排除在外
+     * 新代码只判断 content-type，在 body==null 时才进 else 分支处理 JsonArray
+     */
+    @Test
+    public void testOldConditionBug() {
+        String jsonArrayBody = "[1,2,3]";
+
+        // 旧代码条件：content-type==json && asJsonObject()!=null
+        // 对于 JsonArray body，asJsonObject() 返回 null，整个 if 跳过
+        JsonObject wrongParsed = parseAsJsonObject(jsonArrayBody);
+        boolean oldConditionPassed = wrongParsed != null; // 旧代码的第二个条件
+        Assert.assertFalse("旧代码 bug: JsonArray body 会导致 asJsonObject()==null，整个分支跳过", oldConditionPassed);
+
+        // 新代码：先进 if，body==null 再走 else 解析 JsonArray
+        boolean newConditionFirst = true; // content-type 匹配
+        JsonObject newBody = parseAsJsonObject(jsonArrayBody);
+        boolean newBodyIsNull = newBody == null; // null -> 进 else
+        Assert.assertTrue("新代码: body 解析为 null 时应走 else 分支解析 JsonArray", newBodyIsNull);
+
+        JsonArray newArr = parseAsJsonArray(jsonArrayBody);
+        Assert.assertNotNull("新代码: else 分支正确解析出 JsonArray", newArr);
+
+        System.out.println("[PASS] testOldConditionBug: 修复验证通过，新代码正确处理 JsonArray body");
+    }
+
+    /**
+     * 验证：JsonObject 参数旧代码没有绑定分支（只处理实体类）
+     */
+    @Test
+    public void testOldMissingJsonObjectBranch() {
+        String bodyStr = "{\"key\":\"value\"}";
+        JsonObject body = parseAsJsonObject(bodyStr);
+
+        // 旧代码只调用 matchRegList(entityPackagesReg, typeName)
+        // 对于 io.vertx.core.json.JsonObject，该方法返回 false，不会被绑定
+        String typeName = JsonObject.class.getName(); // "io.vertx.core.json.JsonObject"
+        // entityPackagesReg 一般是 "cn.qaiu.*" 这类，不会匹配 io.vertx
+        boolean oldWouldBind = typeName.startsWith("cn.qaiu"); // 模拟旧代码逻辑
+        Assert.assertFalse("旧代码 bug: JsonObject 参数不会被绑定", oldWouldBind);
+
+        // 新代码：增加了 JsonObject 类型判断
+        boolean newWouldBind = JsonObject.class.getName().equals(typeName);
+        Assert.assertTrue("新代码: JsonObject 参数应能被绑定", newWouldBind);
+
+        System.out.println("[PASS] testOldMissingJsonObjectBranch: 修复验证通过");
+    }
+
+    // ===== 辅助方法：模拟 Vert.x RequestBody 的 asJsonObject/asJsonArray 行为 =====
+
+    private JsonObject parseAsJsonObject(String str) {
+        try {
+            return new JsonObject(str);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private JsonArray parseAsJsonArray(String str) {
+        try {
+            return new JsonArray(str);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}

core/src/test/java/cn/qaiu/vx/core/test/RouterHandlerBindingTest.java

@@ -0,0 +1,125 @@
+package cn.qaiu.vx.core.test;
+
+import cn.qaiu.vx.core.util.VertxHolder;
+import io.vertx.core.Vertx;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 集成测试: 验证 RouterHandlerFactory 对 JsonObject/JsonArray 参数绑定逻辑是否正确
+ *
+ * 运行方式: mvn test-compile -pl core && java -cp "core/target/test-classes:core/target/classes:..." \
+ *            cn.qaiu.vx.core.test.RouterHandlerBindingTest
+ *
+ * 或直接在 IDE 中运行 main 方法。
+ */
+public class RouterHandlerBindingTest {
+
+    static final int TEST_PORT = 18989;
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("=== RouterHandler JsonObject/JsonArray 绑定测试 ===\n");
+
+        // 1. 先初始化 Vert.x 与 VertxHolder ——必须在加载 RouterHandlerFactory 之前
+        Vertx vertx = Vertx.vertx();
+        VertxHolder.init(vertx);
+
+        // 2. 向 SharedData 注入最小化配置
+        //    baseLocations 指向测试包，使 Reflections 只扫描 TestJsonHandler
+        vertx.sharedData().getLocalMap("local").put("customConfig", new JsonObject()
+                .put("baseLocations", "cn.qaiu.vx.core.test")
+                .put("routeTimeOut", 30000)
+                .put("entityPackagesReg", new JsonArray()));
+        // ReverseProxyVerticle.<clinit> 需要 globalConfig.proxyConf（非空字符串即可）
+        vertx.sharedData().getLocalMap("local").put("globalConfig", new JsonObject()
+                .put("proxyConf", "proxy.yml"));
+
+        // 3. 创建 Router（此时才触发 BaseHttpApi.reflections 静态字段初始化）
+        //    用反射延迟加载，确保上面的 SharedData 已就绪
+        cn.qaiu.vx.core.handlerfactory.RouterHandlerFactory factory =
+                new cn.qaiu.vx.core.handlerfactory.RouterHandlerFactory("api");
+        io.vertx.ext.web.Router router = factory.createRouter();
+
+        // 4. 启动 HTTP 服务器
+        CountDownLatch latch = new CountDownLatch(1);
+        vertx.createHttpServer()
+                .requestHandler(router)
+                .listen(TEST_PORT, res -> {
+                    if (res.succeeded()) {
+                        System.out.println("✔ 测试服务器启动成功  port=" + TEST_PORT);
+                    } else {
+                        System.err.println("✘ 服务器启动失败: " + res.cause().getMessage());
+                    }
+                    latch.countDown();
+                });
+
+        if (!latch.await(5, TimeUnit.SECONDS)) {
+            System.err.println("服务器启动超时");
+            vertx.close();
+            System.exit(1);
+        }
+        Thread.sleep(100); // 等 Vert.x 就绪
+
+        // 5. 执行测试
+        boolean allPassed = true;
+        allPassed &= testJsonObject();
+        allPassed &= testJsonArray();
+
+        // 6. 关闭
+        CountDownLatch closeLatch = new CountDownLatch(1);
+        vertx.close(v -> closeLatch.countDown());
+        closeLatch.await(3, TimeUnit.SECONDS);
+
+        System.out.println("\n" + (allPassed ? "✅ 全部测试通过!" : "❌ 存在测试失败!"));
+        System.exit(allPassed ? 0 : 1);
+    }
+
+    // ---------- 子测试 ----------
+
+    private static boolean testJsonObject() throws Exception {
+        String bodyStr = "{\"name\":\"test\",\"value\":123}";
+        String respBody = post("/api/test/json-object", bodyStr);
+        System.out.println("[JsonObject] 响应: " + respBody);
+
+        JsonObject result = new JsonObject(respBody);
+        JsonObject data = result.getJsonObject("data");
+        boolean bound = data != null && Boolean.TRUE.equals(data.getBoolean("bound"));
+        System.out.println("[JsonObject] " + (bound
+                ? "PASS ✅  body 正确绑定为 JsonObject"
+                : "FAIL ❌  body 未绑定 (null)"));
+        return bound;
+    }
+
+    private static boolean testJsonArray() throws Exception {
+        String bodyStr = "[1,2,3]";
+        String respBody = post("/api/test/json-array", bodyStr);
+        System.out.println("[JsonArray]  响应: " + respBody);
+
+        JsonObject result = new JsonObject(respBody);
+        JsonObject data = result.getJsonObject("data");
+        boolean bound = data != null
+                && Boolean.TRUE.equals(data.getBoolean("bound"))
+                && Integer.valueOf(3).equals(data.getInteger("size"));
+        System.out.println("[JsonArray]  " + (bound
+                ? "PASS ✅  body 正确绑定为 JsonArray, size=3"
+                : "FAIL ❌  body 未绑定 或 size 不对"));
+        return bound;
+    }
+
+    private static String post(String path, String body) throws Exception {
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest req = HttpRequest.newBuilder()
+                .uri(URI.create("http://localhost:" + TEST_PORT + path))
+                .header("Content-Type", "application/json")
+                .POST(HttpRequest.BodyPublishers.ofString(body))
+                .build();
+        return client.send(req, HttpResponse.BodyHandlers.ofString()).body();
+    }
+}

core/src/test/java/cn/qaiu/vx/core/test/TestJsonHandler.java

@@ -0,0 +1,36 @@
+package cn.qaiu.vx.core.test;
+
+import cn.qaiu.vx.core.annotaions.RouteHandler;
+import cn.qaiu.vx.core.annotaions.RouteMapping;
+import cn.qaiu.vx.core.enums.MIMEType;
+import cn.qaiu.vx.core.enums.RouteMethod;
+import cn.qaiu.vx.core.model.JsonResult;
+import io.vertx.core.Future;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+/**
+ * 用于测试 RouterHandlerFactory 对 JsonObject/JsonArray 参数绑定的测试 Handler
+ */
+@RouteHandler("test")
+public class TestJsonHandler {
+
+    /** POST /api/test/json-object  Body: {"name":"test","value":123} */
+    @RouteMapping(value = "/json-object", method = RouteMethod.POST, requestMIMEType = MIMEType.APPLICATION_JSON)
+    public Future<JsonResult> testJsonObject(JsonObject body) {
+        // 只返回是否绑定成功及已知字段值，不嵌套原始 body 避免 toJsonObject() 循环
+        boolean bound = body != null;
+        String nameVal = bound ? body.getString("name", "") : "";
+        return Future.succeededFuture(JsonResult.data(new io.vertx.core.json.JsonObject()
+                .put("bound", bound)
+                .put("name", nameVal)));
+    }
+
+    /** POST /api/test/json-array  Body: [1,2,3] */
+    @RouteMapping(value = "/json-array", method = RouteMethod.POST, requestMIMEType = MIMEType.APPLICATION_JSON)
+    public Future<JsonResult> testJsonArray(JsonArray body) {
+        return Future.succeededFuture(JsonResult.data(new io.vertx.core.json.JsonObject()
+                .put("bound", body != null)
+                .put("size", body != null ? body.size() : -1)));
+    }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "mvn": "^3.5.0"
+  }
+}

parser/README.md

@@ -96,7 +96,6 @@ String url = tool.parseSync();
 ## 文档
 - parser/doc/README.md：解析约定、示例、IDEA `.http` 调试
 - **parser/doc/JAVASCRIPT_PARSER_GUIDE.md：JavaScript解析器开发完整指南** - 使用JavaScript编写自定义解析器
-- **parser/doc/PYTHON_PARSER_GUIDE.md：Python解析器开发完整指南** - 使用Python(GraalPy)编写自定义解析器
 - **parser/doc/CUSTOM_PARSER_GUIDE.md：自定义解析器扩展完整指南** - Java自定义解析器扩展
 - **parser/doc/CUSTOM_PARSER_QUICKSTART.md：自定义解析器快速开始** - 快速上手指南
 

parser/doc/API_USAGE.md

@@ -20,6 +20,32 @@
 |------|------|------|------|
 | url | string | ✅ 是 | 分享链接（需URL编码） |
 | pwd | string | ❌ 否 | 分享密码 |
+| auth | string | ❌ 否 | 认证参数（AES加密后的JSON，用于需要登录的网盘） |
+
+### 认证参数说明（v0.2.1+）
+
+部分网盘（如夸克QK、UC网盘）需要登录后的 Cookie 才能解析。`auth` 参数用于传递认证信息：
+
+**加密方式**：
+- 算法：AES/ECB/PKCS5Padding
+- 密钥：`nfd_auth_key2026`（16字节）
+- 流程：JSON → AES加密 → Base64 → URL编码
+
+**JSON 结构**：
+```json
+{
+  "authType": "cookie",        // 认证类型: cookie/accesstoken/authorization
+  "token": "your_cookie_here"  // Cookie 或 Token 内容
+}
+```
+
+**网盘认证要求**：
+| 网盘 | 认证要求 |
+|------|---------|
+| 夸克网盘(QK) | **必须** |
+| UC网盘(UC) | **必须** |
+| 小飞机网盘(FJ) | 大文件需要 |
+| 蓝奏优享(IZ) | 大文件需要 |
 
 ### 请求示例
 

parser/doc/CUSTOM_PARSER_GUIDE.md

@@ -1,14 +1,13 @@
 # 自定义解析器扩展指南
 
-> 最后更新：2026-01-11
+> 最后更新：2025-10-17
 
 ## 概述
 
 本模块支持用户自定义解析器扩展。用户在依赖本项目的 Maven 坐标后，可以实现自己的网盘解析器并注册到系统中使用。
 
-> **提示**：除了Java自定义解析器，本项目还支持使用脚本语言编写解析器，无需编译即可使用：
-> - [JavaScript解析器开发指南](JAVASCRIPT_PARSER_GUIDE.md) - 使用JavaScript编写解析器
-> - [Python解析器开发指南](PYTHON_PARSER_GUIDE.md) - 使用Python编写解析器（基于GraalPy）
+> **提示**：除了Java自定义解析器，本项目还支持使用JavaScript编写解析器，无需编译即可使用。  
+> 查看 [JavaScript解析器开发指南](JAVASCRIPT_PARSER_GUIDE.md) 了解更多。
 
 ## 核心组件
 

parser/doc/JAVASCRIPT_PARSER_GUIDE.md

@@ -4,19 +4,6 @@
 
 本指南介绍如何使用JavaScript编写自定义网盘解析器，支持通过JavaScript代码实现网盘解析逻辑，无需编写Java代码。
 
-### 技术规格
-
-- **JavaScript 引擎**: Nashorn (JDK 8-14 内置)
-- **ECMAScript 版本**: ES5.1 (ECMA-262 5.1 Edition)
-- **语法支持**: ES5 标准语法，不支持 ES6+ 特性（如箭头函数、async/await、模板字符串等）
-- **运行模式**: 同步执行，所有操作都是阻塞式的
-
-### 参考文档
-
-- **ECMAScript 5.1 规范**: https://262.ecma-international.org/5.1/
-- **MDN JavaScript 文档**: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript
-- **Nashorn 用户指南**: https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/nashorn/
-
 ## 目录
 
 - [快速开始](#快速开始)
@@ -724,17 +711,9 @@ var response = http.get("https://api.example.com/data");
 
 ## 相关文档
 
-### 项目文档
 - [自定义解析器扩展指南](CUSTOM_PARSER_GUIDE.md) - Java自定义解析器扩展
 - [自定义解析器快速开始](CUSTOM_PARSER_QUICKSTART.md) - 快速上手指南
 - [解析器开发文档](README.md) - 解析器开发约定和规范
-- [Python解析器开发指南](PYTHON_PARSER_GUIDE.md) - Python 版本解析器指南
-
-### 外部资源
-- **ECMAScript 5.1 规范**: https://262.ecma-international.org/5.1/
-- **MDN JavaScript 参考**: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference
-- **MDN JavaScript 指南**: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide
-- **Nashorn 文档**: https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/nashorn/
 
 ## 更新日志
 

parser/doc/PYLSP_WEBSOCKET_GUIDE.md

@@ -1,215 +0,0 @@
-# Python Playground pylsp WebSocket 集成指南
-
-## 概述
-
-本文档说明了如何将 jedi 的 pylsp (python-lsp-server) 通过 WebSocket 集成到 Python Playground 中，实现实时代码检查、自动完成和悬停提示等功能。
-
-## 架构
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     前端 (Vue + Monaco)                      │
-│  ┌─────────────────────────────────────────────────────────┐│
-│  │  PylspClient.js                                         ││
-│  │  - 通过 WebSocket 发送 LSP JSON-RPC 消息                 ││
-│  │  - 接收诊断信息并转换为 Monaco markers                   ││
-│  └─────────────────────────────────────────────────────────┘│
-└──────────────────────────┬──────────────────────────────────┘
-                           │ WebSocket (SockJS)
-                           ▼
-┌─────────────────────────────────────────────────────────────┐
-│               后端 (Vert.x + SockJS)                         │
-│  ┌─────────────────────────────────────────────────────────┐│
-│  │  PylspWebSocketHandler.java                             ││
-│  │  - @SockRouteMapper("/pylsp/")                          ││
-│  │  - 管理 pylsp 子进程                                     ││
-│  │  - 转发 LSP 消息                                         ││
-│  └─────────────────────────────────────────────────────────┘│
-└──────────────────────────┬──────────────────────────────────┘
-                           │ stdio (LSP协议)
-                           ▼
-┌─────────────────────────────────────────────────────────────┐
-│                pylsp (python-lsp-server)                    │
-│  - jedi: 代码补全、定义跳转                                  │
-│  - pyflakes: 语法错误检查                                    │
-│  - pycodestyle: PEP8 风格检查                               │
-│  - mccabe: 复杂度检查                                       │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## 文件清单
-
-### 后端 (Java)
-
-1. **PylspWebSocketHandler.java**
-   - 路径: `web-service/src/main/java/cn/qaiu/lz/web/controller/PylspWebSocketHandler.java`
-   - 功能: WebSocket 端点，桥接前端与 pylsp 子进程
-   - 端点: `/ws/pylsp/*`
-
-### 前端 (JavaScript/Vue)
-
-1. **pylspClient.js**
-   - 路径: `web-front/src/utils/pylspClient.js`
-   - 功能: LSP WebSocket 客户端，封装 LSP 协议
-
-### 测试
-
-1. **RequestsIntegrationTest.java**
-   - 路径: `web-service/src/test/java/cn/qaiu/lz/web/playground/RequestsIntegrationTest.java`
-   - 功能: requests 库集成测试
-
-2. **test_playground_api.py**
-   - 路径: `web-service/src/test/python/test_playground_api.py`
-   - 功能: API 接口的 pytest 测试脚本
-
-## 使用方法
-
-### 1. 安装 pylsp
-
-```bash
-pip install python-lsp-server[all]
-```
-
-或者只安装核心功能：
-
-```bash
-pip install python-lsp-server jedi
-```
-
-### 2. 前端集成示例
-
-```javascript
-import PylspClient from '@/utils/pylspClient';
-
-// 创建客户端
-const pylsp = new PylspClient({
-  onDiagnostics: (uri, markers) => {
-    // 设置 Monaco Editor markers
-    monaco.editor.setModelMarkers(model, 'pylsp', markers);
-  },
-  onConnected: () => {
-    console.log('pylsp 已连接');
-  },
-  onError: (error) => {
-    console.error('pylsp 错误:', error);
-  }
-});
-
-// 连接
-await pylsp.connect();
-
-// 打开文档
-pylsp.openDocument(pythonCode);
-
-// 更新文档（当代码改变时）
-pylsp.updateDocument(newCode);
-
-// 获取补全
-const completions = await pylsp.getCompletions(line, column);
-
-// 获取悬停信息
-const hover = await pylsp.getHover(line, column);
-
-// 断开连接
-pylsp.disconnect();
-```
-
-### 3. 与 Monaco Editor 集成
-
-```javascript
-// 监听代码变化
-editor.onDidChangeModelContent((e) => {
-  const content = editor.getValue();
-  pylsp.updateDocument(content);
-});
-
-// 注册补全提供者
-monaco.languages.registerCompletionItemProvider('python', {
-  provideCompletionItems: async (model, position) => {
-    const items = await pylsp.getCompletions(
-      position.lineNumber - 1,
-      position.column - 1
-    );
-    return { suggestions: items.map(convertToMonacoItem) };
-  }
-});
-```
-
-## 已知限制
-
-### GraalPy requests 库限制
-
-由于 GraalPy 的 `unicodedata/LLVM` 限制，`requests` 库在后续创建的 Context 中无法正常导入（会抛出 `PolyglotException: null`）。
-
-**错误链**：
-```
-requests → encodings.idna → stringprep → from unicodedata import ucd_3_2_0
-```
-
-**解决方案**：
-1. 在代码顶层导入 requests（不要在函数内部导入）
-2. 使用标准库的 `urllib.request` 作为替代
-3. 首次执行时预热 requests 导入
-
-### 测试注意事项
-
-1. PyPlaygroundFullTest 中的测试2和测试5被标记为跳过（已知限制）
-2. 测试13（前端模板代码）使用不依赖 requests 的版本
-3. requests 功能在实际运行时通过首个 Context 可以正常使用
-
-## 测试命令
-
-### 运行 Java 单元测试
-
-```bash
-# PyPlaygroundFullTest (13 个测试)
-cd parser && mvn exec:java \
-  -Dexec.mainClass="cn.qaiu.parser.custompy.PyPlaygroundFullTest" \
-  -Dexec.classpathScope=test -q
-
-# RequestsIntegrationTest
-cd web-service && mvn exec:java \
-  -Dexec.mainClass="cn.qaiu.lz.web.playground.RequestsIntegrationTest" \
-  -Dexec.classpathScope=test -q
-```
-
-### 运行 Python API 测试
-
-```bash
-# 需要后端服务运行
-cd web-service/src/test/python
-pip install pytest requests
-pytest test_playground_api.py -v
-```
-
-## 配置
-
-### 后端配置
-
-`PylspWebSocketHandler.java` 中可以配置：
-- pylsp 启动命令
-- 心跳间隔
-- 进程超时
-
-### 前端配置
-
-`pylspClient.js` 中可以配置：
-- WebSocket URL
-- 重连次数
-- 重连延迟
-- 请求超时
-
-## 安全考虑
-
-1. pylsp 进程在沙箱环境中运行
-2. 每个 WebSocket 连接对应一个独立的 pylsp 进程
-3. 连接关闭时自动清理进程
-4. Playground 访问需要认证（如果配置了密码）
-
-## 未来改进
-
-1. 支持多文件项目分析
-2. 添加 pyright 类型检查
-3. 支持代码格式化（black/autopep8）
-4. 添加重构功能
-5. 支持虚拟环境选择

parser/doc/PYTHON_PLAYGROUND_TEST_REPORT.md

@@ -1,147 +0,0 @@
-# Python Playground 测试报告
-
-## 测试概述
-
-本文档总结了 Python Playground 功能的单元测试和接口测试结果。
-
-## 测试文件
-
-| 文件 | 位置 | 说明 |
-|------|------|------|
-| `PyPlaygroundFullTest.java` | parser/src/test/java/cn/qaiu/parser/custompy/ | 完整单元测试套件（13个测试） |
-| `PyCodeSecurityCheckerTest.java` | parser/src/test/java/cn/qaiu/parser/custompy/ | 安全检查器测试（17个测试） |
-| `PlaygroundApiTest.java` | parser/src/test/java/cn/qaiu/parser/custompy/ | API接口测试（需要后端运行） |
-
-## 单元测试结果
-
-### PyPlaygroundFullTest - 13/13 通过 ✅
-
-| 测试 | 说明 | 结果 |
-|------|------|------|
-| 测试1 | 基础 Python 执行（1+2, 字符串操作） | ✅ 通过 |
-| 测试2 | requests 库导入 | ⚠️ 跳过（已知限制，功能由测试13验证） |
-| 测试3 | 标准库导入（json, re, base64, hashlib） | ✅ 通过 |
-| 测试4 | 简单 parse 函数 | ✅ 通过 |
-| 测试5 | 带 requests 的 parse 函数 | ⚠️ 跳过（已知限制，功能由测试13验证） |
-| 测试6 | 带 share_link_info 的 parse 函数 | ✅ 通过 |
-| 测试7 | PyPlaygroundExecutor 完整流程 | ✅ 通过 |
-| 测试8 | 安全检查 - 拦截 subprocess | ✅ 通过 |
-| 测试9 | 安全检查 - 拦截 socket | ✅ 通过 |
-| 测试10 | 安全检查 - 拦截 os.system | ✅ 通过 |
-| 测试11 | 安全检查 - 拦截 exec/eval | ✅ 通过 |
-| 测试12 | 安全检查 - 允许安全代码 | ✅ 通过 |
-| 测试13 | 前端模板代码执行（含 requests） | ✅ 通过 |
-
-### PyCodeSecurityCheckerTest - 17/17 通过 ✅
-
-所有安全检查器测试通过，验证了以下功能：
-- 危险模块拦截：subprocess, socket, ctypes, multiprocessing
-- 危险 os 方法拦截：system, popen, execv, fork, spawn, kill
-- 危险内置函数拦截：exec, eval, compile, __import__
-- 危险文件操作拦截：open with write mode
-- 安全代码正确放行
-
-## 已知限制
-
-### GraalPy unicodedata/LLVM 限制
-
-由于 GraalPy 的限制，`requests` 库只能在**第一个**创建的 Context 中成功导入。后续创建的 Context 导入 `requests` 会触发以下错误：
-
-```
-SystemError: GraalPy option 'NativeModules' is set to false, but the 'llvm' language, 
-which is required for this feature, is not available.
-```
-
-**原因**：`requests` 依赖的 `encodings.idna` 模块会导入 `unicodedata`，而该模块需要 LLVM 支持。
-
-**影响**：
-- 在单元测试中，多个测试用例无法同时测试 `requests` 导入
-- 在实际运行中，只要使用 Context 池并确保 `requests` 在代码顶层导入，功能正常
-
-**解决方案**：
-- 确保 `import requests` 放在 Python 代码的顶层，而不是函数内部
-- 前端模板已正确配置，实际使用不受影响
-
-## 运行测试
-
-### 运行单元测试
-
-```bash
-cd parser
-mvn test-compile -q && mvn exec:java \
-  -Dexec.mainClass="cn.qaiu.parser.custompy.PyPlaygroundFullTest" \
-  -Dexec.classpathScope=test -q
-```
-
-### 运行安全检查器测试
-
-```bash
-cd parser
-mvn test-compile -q && mvn exec:java \
-  -Dexec.mainClass="cn.qaiu.parser.custompy.PyCodeSecurityCheckerTest" \
-  -Dexec.classpathScope=test -q
-```
-
-### 运行 API 接口测试
-
-**注意**：需要先启动后端服务
-
-```bash
-# 启动后端服务
-cd web-service && mvn exec:java -Dexec.mainClass=cn.qaiu.lz.AppMain
-
-# 在另一个终端运行测试
-cd parser
-mvn test-compile -q && mvn exec:java \
-  -Dexec.mainClass="cn.qaiu.parser.custompy.PlaygroundApiTest" \
-  -Dexec.classpathScope=test -q
-```
-
-## API 接口测试内容
-
-`PlaygroundApiTest` 测试以下接口：
-
-1. **GET /v2/playground/status** - 获取演练场状态
-2. **POST /v2/playground/test (JavaScript)** - JavaScript 代码执行
-3. **POST /v2/playground/test (Python)** - Python 代码执行
-4. **POST /v2/playground/test (安全检查)** - 验证危险代码被拦截
-5. **POST /v2/playground/test (参数验证)** - 验证缺少参数时的错误处理
-
-## 测试覆盖的核心组件
-
-| 组件 | 说明 | 测试覆盖 |
-|------|------|----------|
-| `PyContextPool` | GraalPy Context 池管理 | ✅ 间接覆盖 |
-| `PyPlaygroundExecutor` | Python 代码执行器 | ✅ 直接测试 |
-| `PyCodeSecurityChecker` | 代码安全检查器 | ✅ 17个测试 |
-| `PyPlaygroundLogger` | 日志记录器 | ✅ 间接覆盖 |
-| `PyShareLinkInfoWrapper` | ShareLinkInfo 包装器 | ✅ 直接测试 |
-| `PyHttpClient` | HTTP 客户端封装 | ⚠️ 部分覆盖 |
-| `PyCryptoUtils` | 加密工具类 | ❌ 未直接测试 |
-
-## 前端模板代码验证
-
-测试13验证了前端 Python 模板代码的完整执行流程：
-
-```python
-import requests
-import re
-import json
-
-def parse(share_link_info, http, logger):
-    share_url = share_link_info.get_share_url()
-    logger.info(f"开始解析: {share_url}")
-    # ... 解析逻辑
-    return "https://download.example.com/test.zip"
-```
-
-验证内容：
-- ✅ `requests` 库导入
-- ✅ `share_link_info.get_share_url()` 调用
-- ✅ `logger.info()` 日志记录
-- ✅ f-string 格式化
-- ✅ 函数返回值处理
-
-## 结论
-
-Python Playground 功能已通过全面测试，核心功能正常工作。唯一的限制是 GraalPy 的 unicodedata/LLVM 问题，但在实际使用中不影响功能。建议在正式部署前进行完整的集成测试。

parser/doc/auth-param/AUTH_PARAM_GUIDE.md

@@ -0,0 +1,341 @@
+# 认证参数传递指南 (Auth Parameter Guide)
+
+## 概述
+
+本文档描述了网盘解析接口中携带认证参数的方法。通过 `auth` 参数，可以在解析请求时传递临时认证信息（如 Cookie、Token、用户名密码等），使解析器能够访问需要登录或授权的网盘资源。
+
+## 网盘认证要求
+
+| 网盘 | 类型代码 | 认证要求 | 说明 |
+|------|---------|---------|------|
+| 夸克网盘 | QK | **必须** | 必须配置 Cookie 才能解析和下载 |
+| UC网盘 | UC | **必须** | 必须配置 Cookie 才能解析和下载 |
+| 小飞机网盘 | FJ | 可选 | 大文件（>100MB）需要配置认证信息 |
+| 蓝奏优享 | IZ | 可选 | 大文件需要配置认证信息 |
+| 其他网盘 | - | 不需要 | 无需认证即可解析 |
+
+> 💡 **如何获取 Cookie**: 在浏览器中登录对应网盘，打开开发者工具（F12），切换到 Network 标签，刷新页面，在请求头中找到 Cookie 字段并复制完整内容。
+
+## 认证参数格式
+
+### 编码流程
+
+```
+JSON对象 → AES加密 → Base64编码 → URL编码
+```
+
+### 解码流程
+
+```
+URL解码 → Base64解码 → AES解密 → JSON对象
+```
+
+### 加密配置
+
+- **加密算法**: AES/ECB/PKCS5Padding
+- **密钥长度**: 16位（128位）
+- **默认密钥**: `nfd_auth_key2026`（可在 `app-dev.yml` 中通过 `server.authEncryptKey` 配置）
+
+### 密钥作用说明（重要）
+
+当前系统中涉及两类不同用途的密钥：
+
+1. `server.authEncryptKey`
+   - 用途：加解密 `auth` 参数（前端/调用方传入的认证信息）
+   - 影响范围：`/parser`、`/json/parser`、`/v2/linkInfo` 等接口中的 `auth` 参数
+   - 注意：这是 **AES 对称加密密钥**，要求 16 位
+
+2. `server.donatedAccountFailureTokenSignKey`
+   - 用途：签名和验签“捐赠账号失败计数 token”（用于防伪造、失败计数）
+   - 影响范围：捐赠账号失败计数与自动失效逻辑
+   - 注意：这是 **HMAC 签名密钥**，与 `authEncryptKey` 已解耦，建议使用高强度随机字符串
+
+> 建议：生产环境务必同时自定义这两个密钥，且不要设置为相同值。
+
+## JSON 模型定义
+
+### AuthParam 对象
+
+```json
+{
+  "authType": "string",     // 认证类型（必填）
+  "username": "string",     // 用户名
+  "password": "string",     // 密码
+  "token": "string",        // Token/AccessToken/Cookie值
+  "cookie": "string",       // Cookie 字符串
+  "auth": "string",         // Authorization 头内容
+  "ext1": "string",         // 扩展字段1（格式: key:value）
+  "ext2": "string",         // 扩展字段2（格式: key:value）
+  "ext3": "string",         // 扩展字段3（格式: key:value）
+  "ext4": "string",         // 扩展字段4（格式: key:value）
+  "ext5": "string"          // 扩展字段5（格式: key:value）
+}
+```
+
+### 认证类型 (authType)
+
+| authType | 说明 | 主要字段 |
+|----------|------|---------|
+| `accesstoken` | 使用 AccessToken 认证 | `token` |
+| `cookie` | 使用 Cookie 认证 | `token` (存放 cookie 值) |
+| `authorization` | 使用 Authorization 头认证 | `token` |
+| `password` / `username_password` | 用户名密码认证 | `username`, `password` |
+| `custom` | 自定义认证（使用扩展字段） | `token`, `ext1`-`ext5` |
+
+### 示例 JSON
+
+#### 1. Token 认证
+```json
+{
+  "authType": "accesstoken",
+  "token": "your_access_token_here"
+}
+```
+
+#### 2. Cookie 认证
+```json
+{
+  "authType": "cookie",
+  "token": "session_id=abc123; user_token=xyz789"
+}
+```
+
+#### 3. 用户名密码认证
+```json
+{
+  "authType": "password",
+  "username": "your_username",
+  "password": "your_password"
+}
+```
+
+#### 4. 自定义认证
+```json
+{
+  "authType": "custom",
+  "token": "main_token",
+  "ext1": "refresh_token:your_refresh_token",
+  "ext2": "device_id:device123"
+}
+```
+
+## 接口调用示例
+
+### 基础接口
+
+#### 1. 解析并重定向 (GET /parser)
+
+```
+GET /parser?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**参数说明:**
+- `url`: 网盘分享链接（必填）
+- `pwd`: 提取码（可选）
+- `auth`: 加密后的认证参数（可选）
+
+**响应:** 302 重定向到直链
+
+#### 2. 解析返回 JSON (GET /json/parser)
+
+```
+GET /json/parser?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**响应示例:**
+```json
+{
+  "shareKey": "lz:xxxx",
+  "directLink": "https://...",
+  "cacheHit": false,
+  "expires": "2026-02-05 12:00:00",
+  "expiration": 1738728000000
+}
+```
+
+#### 3. 获取链接信息 (GET /v2/linkInfo)
+
+```
+GET /v2/linkInfo?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**响应:** 返回下载链接、API 链接、预览链接等信息
+
+## 各语言加密示例
+
+### Java
+
+```java
+import cn.qaiu.lz.common.util.AuthParamCodec;
+import cn.qaiu.lz.web.model.AuthParam;
+
+// 方式1: 使用 AuthParam 对象
+AuthParam authParam = AuthParam.builder()
+    .authType("accesstoken")
+    .token("your_token_here")
+    .build();
+String encrypted = AuthParamCodec.encode(authParam);
+
+// 方式2: 快速编码
+String encrypted = AuthParamCodec.quickEncode("accesstoken", "your_token_here");
+
+// 方式3: 用户名密码
+String encrypted = AuthParamCodec.quickEncodePassword("username", "password");
+
+// 解码
+AuthParam decoded = AuthParamCodec.decode(encrypted);
+```
+
+### JavaScript (浏览器/Node.js)
+
+```javascript
+// 使用 CryptoJS 库
+const CryptoJS = require('crypto-js');
+
+const AUTH_KEY = 'nfd_auth_key2026';
+
+// 加密
+function encodeAuthParam(authObj) {
+    const jsonStr = JSON.stringify(authObj);
+    const encrypted = CryptoJS.AES.encrypt(jsonStr, CryptoJS.enc.Utf8.parse(AUTH_KEY), {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7
+    });
+    const base64 = encrypted.toString();
+    return encodeURIComponent(base64);
+}
+
+// 解密
+function decodeAuthParam(encryptedAuth) {
+    const base64 = decodeURIComponent(encryptedAuth);
+    const decrypted = CryptoJS.AES.decrypt(base64, CryptoJS.enc.Utf8.parse(AUTH_KEY), {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7
+    });
+    return JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
+}
+
+// 使用示例
+const auth = encodeAuthParam({
+    authType: 'accesstoken',
+    token: 'your_token_here'
+});
+const url = `http://127.0.0.1:6400/parser?url=${shareUrl}&auth=${auth}`;
+```
+
+### Python
+
+```python
+import json
+import base64
+from urllib.parse import quote, unquote
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+AUTH_KEY = b'nfd_auth_key2026'
+
+def encode_auth_param(auth_obj):
+    """加密认证参数"""
+    json_str = json.dumps(auth_obj, ensure_ascii=False)
+    cipher = AES.new(AUTH_KEY, AES.MODE_ECB)
+    padded = pad(json_str.encode('utf-8'), AES.block_size)
+    encrypted = cipher.encrypt(padded)
+    base64_str = base64.b64encode(encrypted).decode('utf-8')
+    return quote(base64_str)
+
+def decode_auth_param(encrypted_auth):
+    """解密认证参数"""
+    base64_str = unquote(encrypted_auth)
+    encrypted = base64.b64decode(base64_str)
+    cipher = AES.new(AUTH_KEY, AES.MODE_ECB)
+    decrypted = unpad(cipher.decrypt(encrypted), AES.block_size)
+    return json.loads(decrypted.decode('utf-8'))
+
+# 使用示例
+auth = encode_auth_param({
+    'authType': 'accesstoken',
+    'token': 'your_token_here'
+})
+url = f'http://127.0.0.1:6400/parser?url={share_url}&auth={auth}'
+```
+
+### cURL 命令行
+
+```bash
+# 假设已加密的 auth 参数为 ENCRYPTED_AUTH
+curl -L "http://127.0.0.1:6400/parser?url=https://www.lanzoux.com/xxxx&auth=ENCRYPTED_AUTH"
+
+# 获取 JSON 响应
+curl "http://127.0.0.1:6400/json/parser?url=https://www.lanzoux.com/xxxx&auth=ENCRYPTED_AUTH"
+```
+
+## 解析器使用认证信息
+
+解析器可以从 `shareLinkInfo.otherParam.get("auths")` 获取 MultiMap 格式的认证信息：
+
+```java
+// 在解析器中获取认证信息
+MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+
+if (auths != null) {
+    String authType = auths.get("authType");
+    String token = auths.get("token");
+    String username = auths.get("username");
+    String password = auths.get("password");
+    
+    // 根据 authType 使用相应的认证方式
+    switch (authType) {
+        case "accesstoken":
+            // 使用 token 认证
+            break;
+        case "password":
+            // 使用用户名密码登录
+            break;
+        // ...
+    }
+}
+```
+
+## 注意事项
+
+1. **安全性**: 
+   - 不要在日志中打印完整的认证参数
+   - 认证参数通过 HTTPS 传输更安全
+   - 密钥应妥善保管，建议在生产环境中更换默认密钥
+
+2. **缓存策略**:
+   - 带有临时认证参数的请求目前不会被缓存
+   - 每次请求都会重新解析
+
+3. **兼容性**:
+   - `auth` 参数与原有的 `pwd` 参数可以同时使用
+   - 不提供 `auth` 参数时，使用后台配置的认证信息
+
+4. **扩展字段**:
+   - `ext1`-`ext5` 使用 `key:value` 格式
+   - 适用于需要传递多个自定义参数的场景
+
+## 配置说明
+
+在 `app-dev.yml` 中配置密钥：
+
+```yaml
+server:
+  # auth参数加密密钥（16位AES密钥）
+  authEncryptKey: 'your_custom_key16'
+
+  # 捐赠账号失败计数token签名密钥（HMAC）
+  # 建议使用较长随机字符串，并与 authEncryptKey 不同
+  donatedAccountFailureTokenSignKey: 'your_random_hmac_sign_key'
+```
+
+### 密钥管理建议
+
+- 不要在公开仓库提交生产密钥
+- 建议通过环境变量或私有配置注入
+- 调整 `authEncryptKey` 会影响 `auth` 参数兼容性
+- 调整 `donatedAccountFailureTokenSignKey` 会使已签发的失败计数 token 失效（短期可接受）
+
+## 更新日志
+
+- **2026-02-05**: 初始版本，支持 accesstoken、cookie、password、custom 认证类型

parser/doc/auth-param/AUTH_PARAM_GUIDE_SIMPLE.md

@@ -0,0 +1,118 @@
+# 认证参数传递指南 (简化版)
+
+## JSON 对象模型
+
+### AuthParam 对象
+
+```json
+{
+  "authType": "string",     // 认证类型（必填）
+  "username": "string",     // 用户名
+  "password": "string",     // 密码
+  "token": "string",        // Token/AccessToken/Cookie值
+  "cookie": "string",       // Cookie 字符串
+  "auth": "string",         // Authorization 头内容
+  "ext1": "string",         // 扩展字段1（格式: key:value）
+  "ext2": "string",         // 扩展字段2（格式: key:value）
+  "ext3": "string",         // 扩展字段3（格式: key:value）
+  "ext4": "string",         // 扩展字段4（格式: key:value）
+  "ext5": "string"          // 扩展字段5（格式: key:value）
+}
+```
+
+## 认证类型
+
+| authType | 说明 | 主要字段 |
+|----------|------|---------|
+| `accesstoken` | AccessToken 认证 | `token` |
+| `cookie` | Cookie 认证 | `token` |
+| `authorization` | Authorization 头认证 | `token` |
+| `password` | 用户名密码认证 | `username`, `password` |
+| `custom` | 自定义认证 | `token`, `ext1`-`ext5` |
+
+## 示例
+
+### Token 认证
+```json
+{
+  "authType": "accesstoken",
+  "token": "your_access_token_here"
+}
+```
+
+### Cookie 认证
+```json
+{
+  "authType": "cookie",
+  "token": "session_id=abc123; user_token=xyz789"
+}
+```
+
+### 用户名密码
+```json
+{
+  "authType": "password",
+  "username": "your_username",
+  "password": "your_password"
+}
+```
+
+### 自定义认证
+```json
+{
+  "authType": "custom",
+  "token": "main_token",
+  "ext1": "refresh_token:your_refresh_token",
+  "ext2": "device_id:device123"
+}
+```
+
+## 使用说明
+
+1. **编码流程**: JSON对象 → AES加密 → Base64编码 → URL编码
+2. **加密配置**: AES/ECB/PKCS5Padding, 密钥: `nfd_auth_key2026` (16位)
+3. **接口调用**: `GET /parser?url={分享链接}&pwd={提取码}&auth={加密认证参数}`
+
+
+
+## 接口调用示例
+
+### 基础接口
+
+#### 1. 解析并重定向 (GET /parser)
+
+```
+GET /parser?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**参数说明:**
+- `url`: 网盘分享链接（必填）
+- `pwd`: 提取码（可选）
+- `auth`: 加密后的认证参数（可选）
+
+**响应:** 302 重定向到直链
+
+#### 2. 解析返回 JSON (GET /json/parser)
+
+```
+GET /json/parser?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**响应示例:**
+```json
+{
+  "shareKey": "lz:xxxx",
+  "directLink": "https://...",
+  "cacheHit": false,
+  "expires": "2026-02-05 12:00:00",
+  "expiration": 1738728000000
+}
+```
+
+#### 3. 获取链接信息 (GET /v2/linkInfo)
+
+```
+GET /v2/linkInfo?url={分享链接}&pwd={提取码}&auth={加密认证参数}
+```
+
+**响应:** 返回下载链接、API 链接、预览链接等信息

parser/pom.xml

@@ -12,7 +12,7 @@
 
     <groupId>cn.qaiu</groupId>
     <artifactId>parser</artifactId>
-    <version>10.2.3</version>
+    <version>10.2.5</version>
     <packaging>jar</packaging>
 
     <name>cn.qaiu:parser</name>
@@ -52,29 +52,21 @@
     </distributionManagement>
 
     <properties>
-        <revision>0.1.8</revision>
+        <revision>0.2.1</revision>
         <java.version>17</java.version>
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
         <!-- Versions -->
-        <vertx.version>4.5.23</vertx.version>
+        <vertx.version>4.5.24</vertx.version>
         <org.reflections.version>0.10.2</org.reflections.version>
         <lombok.version>1.18.38</lombok.version>
-        <slf4j.version>2.0.5</slf4j.version>
+        <slf4j.version>2.0.16</slf4j.version>
         <commons-lang3.version>3.18.0</commons-lang3.version>
-        <jackson.version>2.14.2</jackson.version>
+        <jackson.version>2.18.6</jackson.version>
         <logback.version>1.5.19</logback.version>
         <junit.version>4.13.2</junit.version>
-        <!-- GraalPy -->
-        <graalpy.version>24.1.1</graalpy.version>
-        
-        <!-- 代理配置（可选）- 如不需要代理请保持注释 -->
-        <!-- <http.proxyHost>127.0.0.1</http.proxyHost>
-        <http.proxyPort>7890</http.proxyPort>
-        <https.proxyHost>127.0.0.1</https.proxyHost>
-        <https.proxyPort>7890</https.proxyPort> -->
     </properties>
 
     <dependencies>
@@ -113,32 +105,6 @@
             <scope>compile</scope>
         </dependency>
 
-        <!-- GraalPy Python Runtime -->
-        <dependency>
-            <groupId>org.graalvm.polyglot</groupId>
-            <artifactId>polyglot</artifactId>
-            <version>${graalpy.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.graalvm.polyglot</groupId>
-            <artifactId>python</artifactId>
-            <version>${graalpy.version}</version>
-            <type>pom</type>
-        </dependency>
-        <!-- GraalPy Python 包资源支持 -->
-        <dependency>
-            <groupId>org.graalvm.python</groupId>
-            <artifactId>python-embedding</artifactId>
-            <version>${graalpy.version}</version>
-        </dependency>
-        <!-- GraalPy LLVM 支持 - 允许多 Context 使用原生模块 (如 unicodedata) -->
-        <dependency>
-            <groupId>org.graalvm.polyglot</groupId>
-            <artifactId>llvm-community</artifactId>
-            <version>${graalpy.version}</version>
-            <type>pom</type>
-        </dependency>
-
         <!-- Compression (Brotli) -->
         <dependency>
             <groupId>org.brotli</groupId>
@@ -158,40 +124,6 @@
     <build>
         <plugins>
 
-            <!-- GraalPy Maven Plugin - 创建 Python Home 和 venv，自动安装 pip 包 -->
-            <!--
-                注意: python-lsp-server 依赖 ujson（需编译 C 扩展），GraalPy pip 无法安装。
-                如需 python-lsp-server 功能，请运行 setup-graalpy-packages.sh 使用系统 pip 安装。
-                
-                此处只配置 requests 及其纯 Python 依赖，Maven 构建时会自动安装到 
-                target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages/
-            -->
-            <plugin>
-                <groupId>org.graalvm.python</groupId>
-                <artifactId>graalpy-maven-plugin</artifactId>
-                <version>${graalpy.version}</version>
-                <configuration>
-                    <!-- pip 包列表 - 仅纯 Python 包 -->
-                    <packages>
-                        <!-- requests 及其依赖 - HTTP 客户端 (解析器核心功能必需) -->
-                        <package>requests</package>
-                        <package>urllib3</package>
-                        <package>charset_normalizer</package>
-                        <package>idna</package>
-                        <package>certifi</package>
-                    </packages>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>prepare-python-resources</id>
-                        <phase>generate-resources</phase>
-                        <goals>
-                            <goal>process-graalpy-resources</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
             <!-- 编译 -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>

parser/setup-graalpy-packages.sh

@@ -1,127 +0,0 @@
-#!/bin/bash
-# GraalPy pip 包安装脚本
-# 将 pip 包安装到 src/main/resources/graalpy-packages/，可打包进 jar
-# 不受 mvn clean 影响
-#
-# requests 是纯 Python 包，可以用系统 pip 安装
-# GraalPy 运行时可以正常加载这些包
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PARSER_DIR="$SCRIPT_DIR"
-PACKAGES_DIR="$PARSER_DIR/src/main/resources/graalpy-packages"
-
-echo "=== GraalPy pip 包安装脚本 ==="
-echo ""
-echo "目标目录: $PACKAGES_DIR"
-echo ""
-
-# 确保目标目录存在
-mkdir -p "$PACKAGES_DIR"
-
-# 定义要安装的包列表
-# 1. requests 及其依赖 - HTTP 客户端
-# 2. python-lsp-server 及其依赖 - Python LSP 服务器（用于代码智能提示）
-PACKAGES=(
-    # requests 依赖
-    "requests"
-    "urllib3"
-    "charset_normalizer"
-    "idna"
-    "certifi"
-    
-    # python-lsp-server (pylsp) 核心
-    "python-lsp-server"
-    "jedi"
-    "python-lsp-jsonrpc"
-    "pluggy"
-    
-    # pylsp 可选功能
-    "pyflakes"        # 代码检查
-    "pycodestyle"     # PEP8 风格检查
-    "autopep8"        # 自动格式化
-    "rope"            # 重构支持
-    "yapf"            # 代码格式化
-)
-
-echo "将安装以下包到 $PACKAGES_DIR :"
-printf '%s\n' "${PACKAGES[@]}"
-echo ""
-
-# 使用系统 pip 安装包（纯 Python 包）
-echo "开始安装..."
-
-# 尝试不同的 pip 命令
-if command -v pip3 &> /dev/null; then
-    PIP_CMD="pip3"
-elif command -v pip &> /dev/null; then
-    PIP_CMD="pip"
-elif command -v python3 &> /dev/null; then
-    PIP_CMD="python3 -m pip"
-elif command -v python &> /dev/null; then
-    PIP_CMD="python -m pip"
-else
-    echo "✗ 未找到 pip，请先安装 Python 和 pip"
-    exit 1
-fi
-
-echo "使用 pip 命令: $PIP_CMD"
-echo ""
-
-# 安装所有包
-$PIP_CMD install --target="$PACKAGES_DIR" --upgrade "${PACKAGES[@]}" 2>&1
-
-# 验证安装
-echo ""
-echo "验证安装..."
-FAILED=0
-
-if [ -d "$PACKAGES_DIR/requests" ]; then
-    echo "✓ requests 安装成功"
-else
-    echo "✗ requests 安装失败"
-    FAILED=1
-fi
-
-if [ -d "$PACKAGES_DIR/pylsp" ] || [ -d "$PACKAGES_DIR/python_lsp_server" ]; then
-    echo "✓ python-lsp-server 安装成功"
-else
-    echo "✗ python-lsp-server 安装失败"
-    FAILED=1
-fi
-
-if [ -d "$PACKAGES_DIR/jedi" ]; then
-    echo "✓ jedi 安装成功"
-else
-    echo "✗ jedi 安装失败"
-    FAILED=1
-fi
-if [ -d "$PACKAGES_DIR/jedi" ]; then
-    echo "✓ jedi 安装成功"
-else
-    echo "✗ jedi 安装失败"
-    FAILED=1
-fi
-
-if [ $FAILED -eq 1 ]; then
-    echo ""
-    echo "✗ 部分包安装失败，请检查错误信息"
-    exit 1
-fi
-
-# 列出已安装的包
-echo ""
-echo "已安装的主要包:"
-ls -1 "$PACKAGES_DIR" | grep -E "^(requests|jedi|pylsp|python_lsp)" | sort | uniq
-
-echo ""
-echo "=== 安装完成 ==="
-echo ""
-echo "pip 包已安装到: $PACKAGES_DIR"
-echo "此目录会被打包进 jar，不受 mvn clean 影响"
-echo ""
-echo "包含以下功能:"
-echo "  - requests: HTTP 客户端，用于网络请求"
-echo "  - python-lsp-server: Python 语言服务器，提供代码智能提示"
-echo "  - jedi: Python 自动完成和静态分析库"

parser/src/main/java/cn/qaiu/parser/PanBase.java

@@ -56,8 +56,16 @@ public abstract class PanBase implements IPanTool {
     protected WebClient clientNoRedirects = WebClient.create(WebClientVertxInit.get(),
             new WebClientOptions().setFollowRedirects(false));
 
+    /**
+     * Http client disable UserAgent
+     */
+    protected WebClient clientDisableUA = WebClient.create(WebClientVertxInit.get()
+            , new WebClientOptions().setUserAgentEnabled(false)
+    );
+
     protected ShareLinkInfo shareLinkInfo;
     
+
     /**
      * 子类重写此构造方法不需要添加额外逻辑
      * 如:

parser/src/main/java/cn/qaiu/parser/PanDomainTemplate.java

@@ -68,43 +68,44 @@ public enum PanDomainTemplate {
         t-is.cn
      */
     LZ("蓝奏云",
-             compile("https://(?:[a-zA-Z\\d-]+\\.)?(" +
-                      "lanzoul|" +
-                      "lanzouh|" +
-                      "lanosso|" +
-                      "lanpv|" +
-                      "bakstotre|" +
-                      "lanzouo|" +
-                      "lanzov|" +
-                      "lanpw|" +
-                      "ulanzou|" +
-                      "lanzouf|" +
-                      "lanzn|" +
-                      "lanzouj|" +
-                      "lanzouk|" +
-                      "lanzouq|" +
-                      "lanzouv|" +
-                      "lanzoue|" +
-                      "lanzouw|" +
-                      "lanzoub|" +
-                      "lanzouu|" +
-                      "lanwp|" +
-                      "lanzouy|" +
-                      "lanzoup|" +
-                      "woozooo|" +
-                      "lanzv|" +
-                      "dmpdmp|" +
-                      "lanrar|" +
-                      "webgetstore|" +
-                      "lanzb|" +
-                      "lanzoux|" +
-                      "lanzout|" +
-                      "lanzouc|" +
-                      "lanzoui|" +
-                      "lanzoug|" +
-                      "lanzoum" +
-                     ")\\.com/(.+/)?(?<KEY>.+)"),
-            "https://lanzoux.com/{shareKey}",
+            compile("https://(?:[a-zA-Z\\d-]+\\.)?(?:" +
+                    "(?:lanzoul|" +
+                    "lanzouh|" +
+                    "lanosso|" +
+                    "lanpv|" +
+                    "bakstotre|" +
+                    "lanzouo|" +
+                    "lanzov|" +
+                    "lanpw|" +
+                    "ulanzou|" +
+                    "lanzouf|" +
+                    "lanzn|" +
+                    "lanzouj|" +
+                    "lanzouk|" +
+                    "lanzouq|" +
+                    "lanzouv|" +
+                    "lanzoue|" +
+                    "lanzouw|" +
+                    "lanzoub|" +
+                    "lanzouu|" +
+                    "lanwp|" +
+                    "lanzouy|" +
+                    "lanzoup|" +
+                    "woozooo|" +
+                    "lanzv|" +
+                    "dmpdmp|" +
+                    "lanrar|" +
+                    "webgetstore|" +
+                    "lanzb|" +
+                    "lanzoux|" +
+                    "lanzout|" +
+                    "lanzouc|" +
+                    "lanzoui|" +
+                    "lanzoug|" +
+                    "lanzoum)\\.com" +
+                    "|t-is\\.cn" +
+                    ")/(?<KEY>.+)"),
+            "https://w1.lanzn.com/{shareKey}",
             LzTool.class),
 
     // https://www.feijix.com/s/
@@ -114,15 +115,15 @@ public enum PanDomainTemplate {
             "https://www.feijix.com/s/{shareKey}",
             FjTool.class),
 
-    // https://lecloud.lenovo.com/share/
-    LE("联想乐云",
-            compile("https://lecloud?\\.lenovo\\.com/share/(?<KEY>.+)"),
+        // https://lecloud.lenovo.com/share/  https://lecloud.lenovo.com/mshare/
+        LE("联想乐云",
+                        compile("https://lecloud\\.lenovo\\.com/m?share/(?<KEY>.+)"),
             "https://lecloud.lenovo.com/share/{shareKey}",
             LeTool.class),
 
     // https://v2.fangcloud.com/s/
     FC("亿方云",
-            compile("https://v2\\.fangcloud\\.(com|cn)/(s|sharing)/(?<KEY>.+)"),
+            compile("https://v2\\.fangcloud\\.(com|cn)/(s|share|sharing)/(?<KEY>.+)"),
             "https://v2.fangcloud.com/s/{shareKey}",
             "https://www.fangcloud.com/",
             FcTool.class),
@@ -143,9 +144,41 @@ public enum PanDomainTemplate {
             compile("https://qfile\\.qq\\.com/q/(?<KEY>.+)"),
             "https://qfile.qq.com/q/{shareKey}",
             QQscTool.class),
-    // https://f.ws59.cn/f/或者https://www.wenshushu.cn/f/
+    // https://f.ws59.cn/f/ 或者 https://www.wenshushu.cn/f/ 等多个镜像域名
+    /*
+        f.wsNN.cn (如 f.ws59.cn, f.ws28.cn 等)
+        www.wenshushu.cn
+        新增域名:
+        www.wenxiaozhan.net
+        www.wenxiaozhan.cn
+        www.wss.show
+        www.ws28.cn
+        www.wss.email
+        www.wss1.cn
+        www.ws59.cn
+        www.wss.cc
+        www.wss.pet
+        www.wss.ink
+        www.wenxiaozhan.com
+        www.wenshushu.com
+        www.wss.zone
+     */
     WS("文叔叔",
-            compile("https://(f\\.ws(\\d{2})\\.cn|www\\.wenshushu\\.cn)/f/(?<KEY>.+)"),
+            compile("https://(f\\.ws(\\d{2})\\.cn|" +
+                    "www\\.wenxiaozhan\\.net|" +
+                    "www\\.wenxiaozhan\\.cn|" +
+                    "www\\.wss\\.show|" +
+                    "www\\.ws28\\.cn|" +
+                    "www\\.wss\\.email|" +
+                    "www\\.wss1\\.cn|" +
+                    "www\\.ws59\\.cn|" +
+                    "www\\.wss\\.cc|" +
+                    "www\\.wss\\.pet|" +
+                    "www\\.wss\\.ink|" +
+                    "www\\.wenxiaozhan\\.com|" +
+                    "www\\.wenshushu\\.com|" +
+                    "www\\.wss\\.zone|" +
+                    "www\\.wenshushu\\.cn)/f/(?<KEY>.+)"),
             "https://www.wenshushu.cn/f/{shareKey}",
             WsTool.class),
     // https://www.123pan.com/s/
@@ -199,7 +232,7 @@ public enum PanDomainTemplate {
                     "123635\\.com|" +
                     "123242\\.com|" +
                     "123795\\.com"  +
-                    ")/s/(?<KEY>.+)(.html)?"),
+                    ")/s/(?<KEY>[a-zA-Z0-9_-]+)(?:\\.html)?"),
             "https://www.123pan.com/s/{shareKey}",
             Ye2Tool.class),
     // https://www.ecpan.cn/web/#/yunpanProxy?path=%2F%23%2Fdrive%2Foutside&data={code}&isShare=1
@@ -210,7 +243,7 @@ public enum PanDomainTemplate {
             EcTool.class),
     // https://cowtransfer.com/s/
     COW("奶牛快传",
-            compile("https://(.*)cowtransfer\\.com/s/(?<KEY>.+)"),
+            compile("https://(?:[a-zA-Z\\d-]+\\.)?cowtransfer\\.com/s/(?<KEY>.+)"),
             "https://cowtransfer.com/s/{shareKey}",
             CowTool.class),
     CT("城通网盘",
@@ -218,11 +251,6 @@ public enum PanDomainTemplate {
                     "(?<KEY>[0-9a-zA-Z_-]+)(\\?p=(?<PWD>\\w+))?"),
             "https://474b.com/file/{shareKey}",
             CtTool.class),
-    // https://xxx.118pan.com/bxxx
-    P118("118网盘",
-            compile("https://(?:[a-zA-Z\\d-]+\\.)?118pan\\.com/b(?<KEY>.+)"),
-            "https://qaiu.118pan.com/b{shareKey}",
-            P118Tool.class),
     // https://www.vyuyun.com/s/QMa6ie?password=I4KG7H
     // https://www.vyuyun.com/s/QMa6ie/file?password=I4KG7H
     PVYY("微雨云存储",
@@ -238,7 +266,7 @@ public enum PanDomainTemplate {
             PodTool.class),
     // 404网盘 https://drive.google.com/file/d/xxx/view?usp=sharing
     PGD("GoogleDrive",
-            compile("https://drive\\.google\\.com/file/d/(?<KEY>.+)/view(\\?usp=(sharing|drive_link))?"),
+            compile("https://(?:[a-zA-Z\\d-]+\\.)?drive\\.google\\.com/file/d/(?<KEY>.+)/view(\\?usp=(sharing|drive_link))?"),
             "https://drive.google.com/file/d/{shareKey}/view?usp=sharing",
             PgdTool.class),
     // iCloud https://www.icloud.com.cn/iclouddrive/xxx#fonts
@@ -248,11 +276,11 @@ public enum PanDomainTemplate {
             PicTool.class),
     // https://www.dropbox.com/scl/fi/cwnbms1yn8u6rcatzyta7/emqx-5.0.26-el7-amd64.tar.gz?rlkey=3uoi4bxz5mv93jmlaws0nlol1&e=8&st=fe0lclc2&dl=0
     PDB("dropbox",
-            compile("https://www.dropbox.com/scl/fi/(?<KEY>\\w+)/.+?rlkey=(?<PWD>\\w+).*"),
+            compile("https://www\\.dropbox\\.com/scl/fi/(?<KEY>\\w+)/.+?rlkey=(?<PWD>\\w+).*"),
             "https://www.dropbox.com/scl/fi/{shareKey}/?rlkey={pwd}&dl=0",
             PdbTool.class),
     P115("115网盘",
-            compile("https://(115|anxia).com/s/(?<KEY>\\w+)(\\?password=(?<PWD>\\w+))?([&#].*)?"),
+            compile("https://(115|anxia)\\.com/s/(?<KEY>\\w+)(\\?password=(?<PWD>\\w+))?([&#].*)?"),
             "https://115.com/s/{shareKey}?password={pwd}",
             P115Tool.class),
     // 链接：https://www.yunpan.com/surl_yD7wz4VgU9v（提取码：fc70）
@@ -263,7 +291,7 @@ public enum PanDomainTemplate {
 
     // https://pan-yz.cldisk.com/external/m/file/953658049102462976
     Pcx("超星云盘(需要referer头)",
-            compile("https://pan-yz\\.cldisk\\.com/external/m/file/(?<KEY>\\w+)"),
+            compile("https://pan-yz\\.(chaoxing\\.com|cldisk\\.com)/external/m/file/(?<KEY>\\w+)(\\?.*)?"),
             "https://pan-yz.cldisk.com/external/m/file/{shareKey}",
             PcxTool.class),
     // WPS：分享格式：https://www.kdocs.cn/l/ck0azivLlDi3 ；API格式：https://www.kdocs.cn/api/office/file/{shareKey}/download 
@@ -272,6 +300,27 @@ public enum PanDomainTemplate {
             compile("https://(?:[a-zA-Z\\d-]+\\.)?kdocs\\.cn/l/(?<KEY>.+)"),
             "https://www.kdocs.cn/l/{shareKey}",
             PwpsTool.class),
+
+    // https://fast.uc.cn/s/33197dd53ace4
+    // https://drive.uc.cn/s/e623b6da278e4?public=1#/list/share
+    UC("UC网盘",
+            compile("https://(fast|drive)\\.uc\\.cn/s/(?<KEY>\\w+)(\\?public=\\d+)?([&#].*)?"),
+            "https://drive.uc.cn/s/{shareKey}",
+            UcTool.class),
+    // https://pan.quark.cn/s/6a325cdaec58
+    QK("夸克网盘",
+            compile("https://pan\\.quark\\.cn/s/(?<KEY>\\w+)([&#].*)?"),
+            "https://pan.quark.cn/s/{shareKey}",
+            QkTool.class),
+
+    // https://xxx.feishu.cn/file/VnCxbt35KoowKoxldO3c3C7VnMc
+    // https://xxx.feishu.cn/drive/folder/RQSKf8EQ4l7dMedqzHucpMbancg
+    FS("飞书云盘",
+            compile("https://[^.]+\\.feishu\\.cn/(?:file|drive/folder)/(?<KEY>[A-Za-z0-9_-]+)(\\?.*)?"),
+            "https://feishu.cn/file/{shareKey}",
+            "https://www.feishu.cn/",
+            FsTool.class),
+
     // =====================音乐类解析 分享链接标志->MxxS (单歌曲/普通音质)==========================
     // http://163cn.tv/xxx
     MNES("网易云音乐分享",
@@ -280,7 +329,7 @@ public enum PanDomainTemplate {
             MnesTool.class),
     // https://music.163.com/#/song?id=xxx
     MNE("网易云音乐歌曲详情",
-            compile("https://(y.)?music\\.163\\.com/(#|m/)?song\\?id=(?<KEY>.+)(&.*)?"),
+            compile("https://(y\\.)?music\\.163\\.com/(?:#/|m/)?song\\?id=(?<KEY>.+)(&.*)?"),
             "https://music.163.com/#/song?id={shareKey}",
             MnesTool.MneTool.class),
     // https://c6.y.qq.com/base/fcgi-bin/u?__=xxx
@@ -301,7 +350,7 @@ public enum PanDomainTemplate {
             MkgsTool.class),
     // https://www.kugou.com/share/2bi8Fe9CSV3.html?id=2bi8Fe9CSV3#6ed9gna4"
     MKGS2("酷狗音乐分享2",
-            compile("https://(?:[a-zA-Z\\d-]+\\.)?kugou\\.com/share/(?<KEY>.+).html.*"),
+            compile("https://(?:[a-zA-Z\\d-]+\\.)?kugou\\.com/share/(?<KEY>.+)\\.html.*"),
             "https://www.kugou.com/share/{shareKey}.html",
             MkgsTool.Mkgs2Tool.class),
     // https://www.kugou.com/mixsong/2bi8Fe9CSV3

parser/src/main/java/cn/qaiu/parser/ParserCreate.java

@@ -4,7 +4,6 @@ import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.custom.CustomParserConfig;
 import cn.qaiu.parser.custom.CustomParserRegistry;
 import cn.qaiu.parser.customjs.JsParserExecutor;
-import cn.qaiu.parser.custompy.PyParserExecutor;
 
 import org.apache.commons.lang3.StringUtils;
 
@@ -156,9 +155,6 @@ public class ParserCreate {
             // 检查是否为JavaScript解析器
             if (customParserConfig.isJsParser()) {
                 return new JsParserExecutor(shareLinkInfo, customParserConfig);
-            } else if (customParserConfig.isPyParser()) {
-                // Python解析器
-                return new PyParserExecutor(shareLinkInfo, customParserConfig);
             } else {
                 // Java实现的解析器
                 try {

parser/src/main/java/cn/qaiu/parser/clientlink/ClientLinkGeneratorFactory.java

@@ -11,6 +11,13 @@ import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * 客户端下载链接生成器工厂类
+ * <p>
+ * 支持的客户端类型：
+ * <ul>
+ *     <li>CURL - cURL 命令，支持 Cookie</li>
+ *     <li>ARIA2 - Aria2 命令，支持 Cookie</li>
+ *     <li>THUNDER - 迅雷协议，不支持 Cookie</li>
+ * </ul>
  * 
  * @author <a href="https://qaiu.top">QAIU</a>
  * Create at 2025/01/21
@@ -25,16 +32,10 @@ public class ClientLinkGeneratorFactory {
     // 静态初始化块，注册默认的生成器
     static {
         try {
-            // 注册默认生成器 - 按指定顺序注册
-            register(new Aria2LinkGenerator());
-            register(new MotrixLinkGenerator());
-            register(new BitCometLinkGenerator());
-            register(new ThunderLinkGenerator());
-            register(new WgetLinkGenerator());
-            register(new CurlLinkGenerator());
-            register(new IdmLinkGenerator());
-            register(new FdmLinkGenerator());
-            register(new PowerShellLinkGenerator());
+            // 注册默认生成器 - 只保留3种（按需求）
+            register(new CurlLinkGenerator());    // cURL 命令，支持 Cookie
+            register(new Aria2LinkGenerator());   // Aria2 命令，支持 Cookie
+            register(new ThunderLinkGenerator()); // 迅雷协议，不支持 Cookie
             
             log.info("客户端链接生成器工厂初始化完成，已注册 {} 个生成器", generators.size());
         } catch (Exception e) {

parser/src/main/java/cn/qaiu/parser/clientlink/ClientLinkType.java

@@ -2,27 +2,32 @@ package cn.qaiu.parser.clientlink;
 
 /**
  * 客户端下载工具类型枚举
+ * <p>
+ * 支持的客户端类型：
+ * <ul>
+ *     <li>CURL - cURL 命令行工具，支持 Cookie</li>
+ *     <li>ARIA2 - 多线程下载器，支持 Cookie</li>
+ *     <li>THUNDER - 迅雷下载器，不支持 Cookie（使用迅雷协议）</li>
+ * </ul>
  * 
  * @author <a href="https://qaiu.top">QAIU</a>
  * Create at 2025/01/21
  */
 public enum ClientLinkType {
-    ARIA2("aria2", "Aria2"),
-    MOTRIX("motrix", "Motrix"),
-    BITCOMET("bitcomet", "比特彗星"),
-    THUNDER("thunder", "迅雷"),
-    WGET("wget", "wget 命令"),
-    CURL("curl", "cURL 命令"),
-    IDM("idm", "IDM"),
-    FDM("fdm", "Free Download Manager"),
-    POWERSHELL("powershell", "PowerShell");
+    CURL("curl", "cURL 命令", true, "命令行下载工具，支持Cookie"),
+    ARIA2("aria2", "Aria2", true, "多线程下载器，支持Cookie"),
+    THUNDER("thunder", "迅雷", false, "迅雷下载器，不支持Cookie");
     
     private final String code;
     private final String displayName;
+    private final boolean supportsCookie;
+    private final String description;
     
-    ClientLinkType(String code, String displayName) {
+    ClientLinkType(String code, String displayName, boolean supportsCookie, String description) {
         this.code = code;
         this.displayName = displayName;
+        this.supportsCookie = supportsCookie;
+        this.description = description;
     }
     
     public String getCode() {
@@ -33,6 +38,14 @@ public enum ClientLinkType {
         return displayName;
     }
     
+    public boolean isSupportsCookie() {
+        return supportsCookie;
+    }
+    
+    public String getDescription() {
+        return description;
+    }
+    
     @Override
     public String toString() {
         return displayName;

parser/src/main/java/cn/qaiu/parser/clientlink/ClientLinkUtils.java

@@ -7,6 +7,13 @@ import java.util.Map;
 /**
  * 客户端下载链接生成工具类
  * 提供便捷的静态方法来生成各种客户端下载链接
+ * <p>
+ * 支持的客户端类型：
+ * <ul>
+ *     <li>CURL - cURL 命令，支持 Cookie</li>
+ *     <li>ARIA2 - Aria2 命令，支持 Cookie</li>
+ *     <li>THUNDER - 迅雷协议，不支持 Cookie</li>
+ * </ul>
  * 
  * @author <a href="https://qaiu.top">QAIU</a>
  * Create at 2025/01/21
@@ -35,7 +42,7 @@ public class ClientLinkUtils {
     }
     
     /**
-     * 生成 curl 命令
+     * 生成 curl 命令（支持 Cookie）
      * 
      * @param info ShareLinkInfo 对象
      * @return curl 命令字符串
@@ -45,17 +52,7 @@ public class ClientLinkUtils {
     }
     
     /**
-     * 生成 wget 命令
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return wget 命令字符串
-     */
-    public static String generateWgetCommand(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.WGET);
-    }
-    
-    /**
-     * 生成 aria2 命令
+     * 生成 aria2 命令（支持 Cookie）
      * 
      * @param info ShareLinkInfo 对象
      * @return aria2 命令字符串
@@ -65,7 +62,7 @@ public class ClientLinkUtils {
     }
     
     /**
-     * 生成迅雷链接
+     * 生成迅雷链接（不支持 Cookie）
      * 
      * @param info ShareLinkInfo 对象
      * @return 迅雷协议链接
@@ -74,56 +71,6 @@ public class ClientLinkUtils {
         return generateClientLink(info, ClientLinkType.THUNDER);
     }
     
-    /**
-     * 生成 IDM 链接
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return IDM 协议链接
-     */
-    public static String generateIdmLink(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.IDM);
-    }
-    
-    /**
-     * 生成比特彗星链接
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return 比特彗星协议链接
-     */
-    public static String generateBitCometLink(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.BITCOMET);
-    }
-    
-    /**
-     * 生成 Motrix 导入格式
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return Motrix JSON 格式字符串
-     */
-    public static String generateMotrixFormat(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.MOTRIX);
-    }
-    
-    /**
-     * 生成 FDM 导入格式
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return FDM 格式字符串
-     */
-    public static String generateFdmFormat(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.FDM);
-    }
-    
-    /**
-     * 生成 PowerShell 命令
-     * 
-     * @param info ShareLinkInfo 对象
-     * @return PowerShell 命令字符串
-     */
-    public static String generatePowerShellCommand(ShareLinkInfo info) {
-        return generateClientLink(info, ClientLinkType.POWERSHELL);
-    }
-    
     /**
      * 检查 ShareLinkInfo 是否包含有效的下载元数据
      * 

parser/src/main/java/cn/qaiu/parser/clientlink/impl/Aria2LinkGenerator.java

@@ -41,6 +41,8 @@ public class Aria2LinkGenerator implements ClientLinkGenerator {
         parts.add("--continue"); // 支持断点续传
         parts.add("--max-tries=3"); // 最大重试次数
         parts.add("--retry-wait=5"); // 重试等待时间
+        parts.add("-s 8"); // 分成8片段下载
+        parts.add("-x 8"); // 每个服务器使用8个连接
         
         // 添加URL
         parts.add("\"" + meta.getUrl() + "\"");

parser/src/main/java/cn/qaiu/parser/clientlink/impl/BitCometLinkGenerator.java

@@ -1,69 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-
-import java.nio.charset.StandardCharsets;
-import java.util.Base64;
-import java.util.Map;
-
-/**
- * 比特彗星协议链接生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class BitCometLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        try {
-            // 比特彗星支持 HTTP 下载，格式类似 IDM
-            String encodedUrl = Base64.getEncoder().encodeToString(
-                meta.getUrl().getBytes(StandardCharsets.UTF_8)
-            );
-            
-            StringBuilder link = new StringBuilder("bitcomet:///?url=").append(encodedUrl);
-            
-            // 添加请求头
-            if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-                StringBuilder headerStr = new StringBuilder();
-                for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                    if (headerStr.length() > 0) {
-                        headerStr.append("\\r\\n");
-                    }
-                    headerStr.append(entry.getKey()).append(": ").append(entry.getValue());
-                }
-                
-                String encodedHeaders = Base64.getEncoder().encodeToString(
-                    headerStr.toString().getBytes(StandardCharsets.UTF_8)
-                );
-                link.append("&header=").append(encodedHeaders);
-            }
-            
-            // 添加文件名
-            if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-                String encodedFileName = Base64.getEncoder().encodeToString(
-                    meta.getFileName().getBytes(StandardCharsets.UTF_8)
-                );
-                link.append("&filename=").append(encodedFileName);
-            }
-            
-            return link.toString();
-            
-        } catch (Exception e) {
-            // 如果编码失败，返回简单的URL
-            return "bitcomet:///?url=" + meta.getUrl();
-        }
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.BITCOMET;
-    }
-}

parser/src/main/java/cn/qaiu/parser/clientlink/impl/FdmLinkGenerator.java

@@ -1,56 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-
-import java.util.Map;
-
-/**
- * Free Download Manager 导入格式生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class FdmLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        // FDM 支持简单的文本格式导入
-        StringBuilder result = new StringBuilder();
-        result.append("URL=").append(meta.getUrl()).append("\n");
-        
-        // 添加文件名
-        if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-            result.append("Filename=").append(meta.getFileName()).append("\n");
-        }
-        
-        // 添加请求头
-        if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-            result.append("Headers=");
-            boolean first = true;
-            for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                if (!first) {
-                    result.append("; ");
-                }
-                result.append(entry.getKey()).append(": ").append(entry.getValue());
-                first = false;
-            }
-            result.append("\n");
-        }
-        
-        result.append("Referer=").append(meta.getReferer() != null ? meta.getReferer() : "").append("\n");
-        result.append("User-Agent=").append(meta.getUserAgent() != null ? meta.getUserAgent() : "").append("\n");
-        
-        return result.toString();
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.FDM;
-    }
-}

parser/src/main/java/cn/qaiu/parser/clientlink/impl/IdmLinkGenerator.java

@@ -1,69 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-
-import java.nio.charset.StandardCharsets;
-import java.util.Base64;
-import java.util.Map;
-
-/**
- * IDM 协议链接生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class IdmLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        try {
-            // 对URL进行Base64编码
-            String encodedUrl = Base64.getEncoder().encodeToString(
-                meta.getUrl().getBytes(StandardCharsets.UTF_8)
-            );
-            
-            StringBuilder link = new StringBuilder("idm:///?url=").append(encodedUrl);
-            
-            // 添加请求头
-            if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-                StringBuilder headerStr = new StringBuilder();
-                for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                    if (headerStr.length() > 0) {
-                        headerStr.append("\\r\\n");
-                    }
-                    headerStr.append(entry.getKey()).append(": ").append(entry.getValue());
-                }
-                
-                String encodedHeaders = Base64.getEncoder().encodeToString(
-                    headerStr.toString().getBytes(StandardCharsets.UTF_8)
-                );
-                link.append("&header=").append(encodedHeaders);
-            }
-            
-            // 添加文件名
-            if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-                String encodedFileName = Base64.getEncoder().encodeToString(
-                    meta.getFileName().getBytes(StandardCharsets.UTF_8)
-                );
-                link.append("&filename=").append(encodedFileName);
-            }
-            
-            return link.toString();
-            
-        } catch (Exception e) {
-            // 如果编码失败，返回简单的URL
-            return "idm:///?url=" + meta.getUrl();
-        }
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.IDM;
-    }
-}

parser/src/main/java/cn/qaiu/parser/clientlink/impl/MotrixLinkGenerator.java

@@ -1,53 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-import io.vertx.core.json.JsonObject;
-
-import java.util.Map;
-
-/**
- * Motrix 导入格式生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class MotrixLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        // 使用 Vert.x JsonObject 构建 JSON
-        JsonObject taskJson = new JsonObject();
-        taskJson.put("url", meta.getUrl());
-        
-        // 添加文件名
-        if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-            taskJson.put("filename", meta.getFileName());
-        }
-        
-        // 添加请求头
-        if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-            JsonObject headersJson = new JsonObject();
-            for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                headersJson.put(entry.getKey(), entry.getValue());
-            }
-            taskJson.put("headers", headersJson);
-        }
-        
-        // 设置输出文件名
-        String outputFile = meta.getFileName() != null ? meta.getFileName() : "";
-        taskJson.put("out", outputFile);
-        
-        return taskJson.encodePrettily();
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.MOTRIX;
-    }
-}

parser/src/main/java/cn/qaiu/parser/clientlink/impl/PowerShellLinkGenerator.java

@@ -1,98 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * PowerShell 命令生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class PowerShellLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        List<String> lines = new ArrayList<>();
-        
-        // 创建 WebRequestSession
-        lines.add("$session = New-Object Microsoft.PowerShell.Commands.WebRequestSession");
-        
-        // 设置 User-Agent（如果存在）
-        String userAgent = meta.getUserAgent();
-        if (userAgent == null && meta.getHeaders() != null) {
-            userAgent = meta.getHeaders().get("User-Agent");
-        }
-        if (userAgent != null && !userAgent.trim().isEmpty()) {
-            lines.add("$session.UserAgent = \"" + escapePowerShellString(userAgent) + "\"");
-        }
-        
-        // 构建 Invoke-WebRequest 命令
-        List<String> invokeParams = new ArrayList<>();
-        invokeParams.add("Invoke-WebRequest");
-        invokeParams.add("-UseBasicParsing");
-        invokeParams.add("-Uri \"" + escapePowerShellString(meta.getUrl()) + "\"");
-        
-        // 添加 WebSession
-        invokeParams.add("-WebSession $session");
-        
-        // 添加请求头
-        if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-            List<String> headerLines = new ArrayList<>();
-            headerLines.add("-Headers @{");
-            
-            boolean first = true;
-            for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                if (!first) {
-                    headerLines.add("");
-                }
-                headerLines.add("  \"" + escapePowerShellString(entry.getKey()) + "\"=\"" + 
-                              escapePowerShellString(entry.getValue()) + "\"");
-                first = false;
-            }
-            
-            headerLines.add("}");
-            
-            // 将头部参数添加到主命令中
-            invokeParams.add(String.join("`\n", headerLines));
-        }
-        
-        // 设置输出文件（如果指定了文件名）
-        if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-            invokeParams.add("-OutFile \"" + escapePowerShellString(meta.getFileName()) + "\"");
-        }
-        
-        // 将所有参数连接起来
-        String invokeCommand = String.join(" `\n", invokeParams);
-        lines.add(invokeCommand);
-        
-        return String.join("\n", lines);
-    }
-    
-    /**
-     * 转义 PowerShell 字符串中的特殊字符
-     */
-    private String escapePowerShellString(String str) {
-        if (str == null) {
-            return "";
-        }
-        
-        return str.replace("`", "``")
-                 .replace("\"", "`\"")
-                 .replace("$", "`$");
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.POWERSHELL;
-    }
-}

parser/src/main/java/cn/qaiu/parser/clientlink/impl/WgetLinkGenerator.java

@@ -1,51 +0,0 @@
-package cn.qaiu.parser.clientlink.impl;
-
-import cn.qaiu.parser.clientlink.ClientLinkGenerator;
-import cn.qaiu.parser.clientlink.ClientLinkType;
-import cn.qaiu.parser.clientlink.DownloadLinkMeta;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * wget 命令生成器
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2025/01/21
- */
-public class WgetLinkGenerator implements ClientLinkGenerator {
-    
-    @Override
-    public String generate(DownloadLinkMeta meta) {
-        if (!supports(meta)) {
-            return null;
-        }
-        
-        List<String> parts = new ArrayList<>();
-        parts.add("wget");
-        
-        // 添加请求头
-        if (meta.getHeaders() != null && !meta.getHeaders().isEmpty()) {
-            for (Map.Entry<String, String> entry : meta.getHeaders().entrySet()) {
-                parts.add("--header=\"" + entry.getKey() + ": " + entry.getValue() + "\"");
-            }
-        }
-        
-        // 设置输出文件名
-        if (meta.getFileName() != null && !meta.getFileName().trim().isEmpty()) {
-            parts.add("-O");
-            parts.add("\"" + meta.getFileName() + "\"");
-        }
-        
-        // 添加URL
-        parts.add("\"" + meta.getUrl() + "\"");
-        
-        return String.join(" \\\n     ", parts);
-    }
-    
-    @Override
-    public ClientLinkType getType() {
-        return ClientLinkType.WGET;
-    }
-}

parser/src/main/java/cn/qaiu/parser/custom/CustomParserConfig.java

@@ -53,26 +53,11 @@ public class CustomParserConfig {
      */
     private final String jsCode;
 
-    /**
-     * Python代码（用于Python解析器）
-     */
-    private final String pyCode;
-
     /**
      * 是否为JavaScript解析器
      */
     private final boolean isJsParser;
 
-    /**
-     * 是否为Python解析器
-     */
-    private final boolean isPyParser;
-
-    /**
-     * 脚本语言类型：javascript, python
-     */
-    private final String language;
-
     /**
      * 元数据信息（从脚本注释中解析）
      */
@@ -86,10 +71,7 @@ public class CustomParserConfig {
         this.panDomain = builder.panDomain;
         this.matchPattern = builder.matchPattern;
         this.jsCode = builder.jsCode;
-        this.pyCode = builder.pyCode;
         this.isJsParser = builder.isJsParser;
-        this.isPyParser = builder.isPyParser;
-        this.language = builder.language;
         this.metadata = builder.metadata;
     }
 
@@ -121,22 +103,10 @@ public class CustomParserConfig {
         return jsCode;
     }
 
-    public String getPyCode() {
-        return pyCode;
-    }
-
     public boolean isJsParser() {
         return isJsParser;
     }
 
-    public boolean isPyParser() {
-        return isPyParser;
-    }
-
-    public String getLanguage() {
-        return language;
-    }
-
     public Map<String, String> getMetadata() {
         return metadata;
     }
@@ -164,10 +134,7 @@ public class CustomParserConfig {
         private String panDomain;
         private Pattern matchPattern;
         private String jsCode;
-        private String pyCode;
         private boolean isJsParser;
-        private boolean isPyParser;
-        private String language;
         private Map<String, String> metadata;
 
         /**
@@ -244,45 +211,12 @@ public class CustomParserConfig {
             return this;
         }
 
-        /**
-         * 设置Python代码（用于Python解析器）
-         * @param pyCode Python代码
-         */
-        public Builder pyCode(String pyCode) {
-            this.pyCode = pyCode;
-            return this;
-        }
-
         /**
          * 设置是否为JavaScript解析器
          * @param isJsParser 是否为JavaScript解析器
          */
         public Builder isJsParser(boolean isJsParser) {
             this.isJsParser = isJsParser;
-            if (isJsParser) {
-                this.language = "javascript";
-            }
-            return this;
-        }
-
-        /**
-         * 设置是否为Python解析器
-         * @param isPyParser 是否为Python解析器
-         */
-        public Builder isPyParser(boolean isPyParser) {
-            this.isPyParser = isPyParser;
-            if (isPyParser) {
-                this.language = "python";
-            }
-            return this;
-        }
-
-        /**
-         * 设置脚本语言类型
-         * @param language 语言类型：javascript, python
-         */
-        public Builder language(String language) {
-            this.language = language;
             return this;
         }
 
@@ -312,11 +246,6 @@ public class CustomParserConfig {
                 if (jsCode == null || jsCode.trim().isEmpty()) {
                     throw new IllegalArgumentException("JavaScript解析器的jsCode不能为空");
                 }
-            } else if (isPyParser) {
-                // 如果是Python解析器，验证pyCode
-                if (pyCode == null || pyCode.trim().isEmpty()) {
-                    throw new IllegalArgumentException("Python解析器的pyCode不能为空");
-                }
             } else {
                 // 如果是Java解析器，验证toolClass
                 if (toolClass == null) {
@@ -359,10 +288,7 @@ public class CustomParserConfig {
                 ", panDomain='" + panDomain + '\'' +
                 ", matchPattern=" + (matchPattern != null ? matchPattern.pattern() : "null") +
                 ", jsCode=" + (jsCode != null ? "[JavaScript代码]" : "null") +
-                ", pyCode=" + (pyCode != null ? "[Python代码]" : "null") +
                 ", isJsParser=" + isJsParser +
-                ", isPyParser=" + isPyParser +
-                ", language='" + language + '\'' +
                 ", metadata=" + metadata +
                 '}';
     }

parser/src/main/java/cn/qaiu/parser/custom/CustomParserRegistry.java

@@ -6,8 +6,6 @@ import org.slf4j.LoggerFactory;
 import cn.qaiu.parser.PanDomainTemplate;
 import cn.qaiu.parser.customjs.JsScriptLoader;
 import cn.qaiu.parser.customjs.JsScriptMetadataParser;
-import cn.qaiu.parser.custompy.PyScriptLoader;
-import cn.qaiu.parser.custompy.PyScriptMetadataParser;
 
 import java.util.List;
 import java.util.Map;
@@ -84,24 +82,6 @@ public class CustomParserRegistry {
         register(config);
     }
 
-    /**
-     * 注册Python解析器
-     *
-     * @param config Python解析器配置
-     * @throws IllegalArgumentException 如果type已存在或与内置解析器冲突
-     */
-    public static void registerPy(CustomParserConfig config) {
-        if (config == null) {
-            throw new IllegalArgumentException("config不能为空");
-        }
-        
-        if (!config.isPyParser()) {
-            throw new IllegalArgumentException("config必须是Python解析器配置");
-        }
-        
-        register(config);
-    }
-
     /**
      * 从JavaScript代码字符串注册解析器
      *
@@ -159,63 +139,6 @@ public class CustomParserRegistry {
         }
     }
 
-    /**
-     * 从Python代码字符串注册解析器
-     *
-     * @param pyCode Python代码
-     * @throws IllegalArgumentException 如果解析失败
-     */
-    public static void registerPyFromCode(String pyCode) {
-        if (pyCode == null || pyCode.trim().isEmpty()) {
-            throw new IllegalArgumentException("Python代码不能为空");
-        }
-        
-        try {
-            CustomParserConfig config = PyScriptMetadataParser.parseScript(pyCode);
-            registerPy(config);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("解析Python代码失败: " + e.getMessage(), e);
-        }
-    }
-
-    /**
-     * 从文件注册Python解析器
-     *
-     * @param filePath 文件路径
-     * @throws IllegalArgumentException 如果文件不存在或解析失败
-     */
-    public static void registerPyFromFile(String filePath) {
-        if (filePath == null || filePath.trim().isEmpty()) {
-            throw new IllegalArgumentException("文件路径不能为空");
-        }
-        
-        try {
-            CustomParserConfig config = PyScriptLoader.loadFromFile(filePath);
-            registerPy(config);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("从文件加载Python解析器失败: " + e.getMessage(), e);
-        }
-    }
-
-    /**
-     * 从资源文件注册Python解析器
-     *
-     * @param resourcePath 资源路径
-     * @throws IllegalArgumentException 如果资源不存在或解析失败
-     */
-    public static void registerPyFromResource(String resourcePath) {
-        if (resourcePath == null || resourcePath.trim().isEmpty()) {
-            throw new IllegalArgumentException("资源路径不能为空");
-        }
-        
-        try {
-            CustomParserConfig config = PyScriptLoader.loadFromResource(resourcePath);
-            registerPy(config);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("从资源加载Python解析器失败: " + e.getMessage(), e);
-        }
-    }
-
     /**
      * 自动加载所有JavaScript脚本
      */
@@ -242,40 +165,6 @@ public class CustomParserRegistry {
         }
     }
 
-    /**
-     * 自动加载所有Python脚本
-     */
-    public static void autoLoadPyScripts() {
-        try {
-            List<CustomParserConfig> configs = PyScriptLoader.loadAllScripts();
-            int successCount = 0;
-            int failCount = 0;
-            
-            for (CustomParserConfig config : configs) {
-                try {
-                    registerPy(config);
-                    successCount++;
-                } catch (Exception e) {
-                    log.error("加载Python脚本失败: {}", config.getType(), e);
-                    failCount++;
-                }
-            }
-            
-            log.info("自动加载Python脚本完成: 成功 {} 个，失败 {} 个", successCount, failCount);
-            
-        } catch (Exception e) {
-            log.error("自动加载Python脚本时发生异常", e);
-        }
-    }
-
-    /**
-     * 自动加载所有脚本（JavaScript和Python）
-     */
-    public static void autoLoadAllScripts() {
-        autoLoadJsScripts();
-        autoLoadPyScripts();
-    }
-
     /**
      * 注销自定义解析器
      *

parser/src/main/java/cn/qaiu/parser/custompy/PyCodePreprocessor.java

@@ -1,280 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.regex.Pattern;
-
-/**
- * Python代码预处理器
- * 用于在运行时自动检测代码中的网络请求导入，并动态注入requests_guard猴子补丁
- * 
- * 功能：
- * 1. 检测代码中是否导入了 requests、urllib、httpx 等网络请求库
- * 2. 如果检测到网络请求库，自动在代码头部注入 requests_guard 猴子补丁
- * 3. 生成日志信息供演练场控制台显示
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- */
-public class PyCodePreprocessor {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyCodePreprocessor.class);
-    
-    // 检测网络请求库的正则表达式
-    private static final Pattern IMPORT_REQUESTS = Pattern.compile(
-            "^\\s*(?:import\\s+requests|from\\s+requests\\b)",
-            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE
-    );
-    
-    private static final Pattern IMPORT_URLLIB = Pattern.compile(
-            "^\\s*(?:import\\s+urllib|from\\s+urllib\\b)",
-            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE
-    );
-    
-    private static final Pattern IMPORT_HTTPX = Pattern.compile(
-            "^\\s*(?:import\\s+httpx|from\\s+httpx\\b)",
-            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE
-    );
-    
-    private static final Pattern IMPORT_AIOHTTP = Pattern.compile(
-            "^\\s*(?:import\\s+aiohttp|from\\s+aiohttp\\b)",
-            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE
-    );
-    
-    private static final Pattern IMPORT_SOCKET = Pattern.compile(
-            "^\\s*(?:import\\s+socket|from\\s+socket\\b)",
-            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE
-    );
-    
-    /**
-     * 预处理Python代码 - 检测并注入猴子补丁
-     * 
-     * @param originalCode 原始Python代码
-     * @return 处理后的代码（可能包含注入的补丁）
-     */
-    public static PyPreprocessResult preprocess(String originalCode) {
-        if (originalCode == null || originalCode.trim().isEmpty()) {
-            return new PyPreprocessResult(originalCode, false, null, "代码为空，无需预处理");
-        }
-        
-        // 检测网络请求库
-        NetworkLibraryDetection detection = detectNetworkLibraries(originalCode);
-        
-        if (detection.hasAnyNetworkLibrary()) {
-            log.debug("检测到网络请求库: {}", detection.getDetectedLibraries());
-            
-            // 加载猴子补丁代码
-            String patchCode = loadRequestsGuardPatch();
-            
-            if (patchCode != null && !patchCode.isEmpty()) {
-                // 在代码头部注入补丁
-                String preprocessedCode = injectPatch(originalCode, patchCode);
-                
-                String logMessage = String.format(
-                        "✓ 网络请求安全拦截已启用 (检测到: %s) | 已动态注入 requests_guard 猴子补丁",
-                        detection.getDetectedLibrariesAsString()
-                );
-                
-                log.info(logMessage);
-                return new PyPreprocessResult(
-                        preprocessedCode, 
-                        true, 
-                        detection.getDetectedLibraries(),
-                        logMessage
-                );
-            } else {
-                String logMessage = "⚠ 检测到网络请求库但猴子补丁加载失败，请检查资源文件";
-                log.warn(logMessage);
-                return new PyPreprocessResult(
-                        originalCode,
-                        false,
-                        detection.getDetectedLibraries(),
-                        logMessage
-                );
-            }
-        } else {
-            // 没有检测到网络请求库
-            String logMessage = "ℹ 代码中未检测到网络请求库，不需要注入安全拦截补丁";
-            log.debug(logMessage);
-            return new PyPreprocessResult(originalCode, false, null, logMessage);
-        }
-    }
-    
-    /**
-     * 检测代码中使用的网络请求库
-     */
-    private static NetworkLibraryDetection detectNetworkLibraries(String code) {
-        NetworkLibraryDetection detection = new NetworkLibraryDetection();
-        
-        if (IMPORT_REQUESTS.matcher(code).find()) {
-            detection.addLibrary("requests");
-        }
-        if (IMPORT_URLLIB.matcher(code).find()) {
-            detection.addLibrary("urllib");
-        }
-        if (IMPORT_HTTPX.matcher(code).find()) {
-            detection.addLibrary("httpx");
-        }
-        if (IMPORT_AIOHTTP.matcher(code).find()) {
-            detection.addLibrary("aiohttp");
-        }
-        if (IMPORT_SOCKET.matcher(code).find()) {
-            detection.addLibrary("socket");
-        }
-        
-        return detection;
-    }
-    
-    /**
-     * 加载requests_guard猴子补丁代码
-     */
-    private static String loadRequestsGuardPatch() {
-        try {
-            // 从资源文件加载requests_guard.py
-            InputStream inputStream = PyCodePreprocessor.class.getClassLoader()
-                    .getResourceAsStream("requests_guard.py");
-            
-            if (inputStream == null) {
-                log.warn("无法找到 requests_guard.py 资源文件");
-                return null;
-            }
-            
-            StringBuilder content = new StringBuilder();
-            try (BufferedReader reader = new BufferedReader(
-                    new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
-                String line;
-                while ((line = reader.readLine()) != null) {
-                    content.append(line).append("\n");
-                }
-            }
-            
-            return content.toString();
-        } catch (IOException e) {
-            log.error("加载 requests_guard.py 失败", e);
-            return null;
-        }
-    }
-    
-    /**
-     * 在Python代码头部注入补丁
-     * 
-     * @param originalCode 原始代码
-     * @param patchCode 补丁代码
-     * @return 注入补丁后的代码
-     */
-    private static String injectPatch(String originalCode, String patchCode) {
-        // 找到第一个非注释、非空行作为注入位置
-        String[] lines = originalCode.split("\n");
-        int insertIndex = 0;
-        
-        // 跳过模块文档字符串和注释
-        for (int i = 0; i < lines.length; i++) {
-            String line = lines[i].trim();
-            
-            // 跳过空行和注释
-            if (line.isEmpty() || line.startsWith("#")) {
-                insertIndex = i + 1;
-                continue;
-            }
-            
-            // 跳过模块文档字符串 (""" 或 ''')
-            if (line.startsWith("\"\"\"") || line.startsWith("'''")) {
-                // 简单处理：假设文档字符串在单行内或下一行结束
-                insertIndex = i + 1;
-                if (line.length() > 3 && !line.endsWith(line.substring(0, 3))) {
-                    continue; // 多行文档字符串，继续跳过
-                }
-            }
-            
-            // 找到第一个有效的代码行
-            break;
-        }
-        
-        // 构建注入后的代码
-        StringBuilder result = new StringBuilder();
-        
-        // 添加前面的行
-        for (int i = 0; i < insertIndex && i < lines.length; i++) {
-            result.append(lines[i]).append("\n");
-        }
-        
-        // 添加补丁代码
-        result.append("\n# ===== 自动注入的网络请求安全补丁 (由 PyCodePreprocessor 生成) =====\n");
-        result.append(patchCode);
-        result.append("\n# ===== 安全补丁结束 =====\n\n");
-        
-        // 添加剩余的代码
-        for (int i = insertIndex; i < lines.length; i++) {
-            result.append(lines[i]);
-            if (i < lines.length - 1) {
-                result.append("\n");
-            }
-        }
-        
-        return result.toString();
-    }
-    
-    /**
-     * 预处理结果类
-     */
-    public static class PyPreprocessResult {
-        private final String processedCode;      // 处理后的代码
-        private final boolean patchInjected;     // 是否注入了补丁
-        private final java.util.List<String> detectedLibraries;  // 检测到的库
-        private final String logMessage;         // 日志消息
-        
-        public PyPreprocessResult(String processedCode, boolean patchInjected, 
-                                java.util.List<String> detectedLibraries, String logMessage) {
-            this.processedCode = processedCode;
-            this.patchInjected = patchInjected;
-            this.detectedLibraries = detectedLibraries;
-            this.logMessage = logMessage;
-        }
-        
-        public String getProcessedCode() {
-            return processedCode;
-        }
-        
-        public boolean isPatchInjected() {
-            return patchInjected;
-        }
-        
-        public java.util.List<String> getDetectedLibraries() {
-            return detectedLibraries;
-        }
-        
-        public String getLogMessage() {
-            return logMessage;
-        }
-    }
-    
-    /**
-     * 网络库检测结果
-     */
-    private static class NetworkLibraryDetection {
-        private final java.util.List<String> detectedLibraries = new java.util.ArrayList<>();
-        
-        void addLibrary(String library) {
-            if (!detectedLibraries.contains(library)) {
-                detectedLibraries.add(library);
-            }
-        }
-        
-        boolean hasAnyNetworkLibrary() {
-            return !detectedLibraries.isEmpty();
-        }
-        
-        java.util.List<String> getDetectedLibraries() {
-            return detectedLibraries;
-        }
-        
-        String getDetectedLibrariesAsString() {
-            return String.join(", ", detectedLibraries);
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyCodeSecurityChecker.java

@@ -1,202 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Python 代码安全检查器
- * 在执行前对代码进行静态分析，检测危险操作
- */
-public class PyCodeSecurityChecker {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyCodeSecurityChecker.class);
-    
-    /**
-     * 危险的导入模块
-     */
-    private static final Set<String> DANGEROUS_IMPORTS = Set.of(
-            "subprocess",    // 子进程执行
-            "socket",        // 原始网络套接字
-            "ctypes",        // C 语言接口
-            "_ctypes",       // C 语言接口
-            "multiprocessing", // 多进程
-            "threading",     // 多线程（可选禁止）
-            "asyncio",       // 异步IO（可选禁止）
-            "pty",           // 伪终端
-            "fcntl",         // 文件控制
-            "resource",      // 资源限制
-            "syslog",        // 系统日志
-            "signal"         // 信号处理
-    );
-    
-    /**
-     * 危险的 os 模块方法
-     */
-    private static final Set<String> DANGEROUS_OS_METHODS = Set.of(
-            "system",        // 执行系统命令
-            "popen",         // 打开进程管道
-            "spawn",         // 生成进程
-            "spawnl", "spawnle", "spawnlp", "spawnlpe",
-            "spawnv", "spawnve", "spawnvp", "spawnvpe",
-            "exec", "execl", "execle", "execlp", "execlpe",
-            "execv", "execve", "execvp", "execvpe",
-            "fork", "forkpty",
-            "kill", "killpg",
-            "remove", "unlink",
-            "rmdir", "removedirs",
-            "mkdir", "makedirs",
-            "rename", "renames", "replace",
-            "chmod", "chown", "lchown",
-            "chroot",
-            "mknod", "mkfifo",
-            "link", "symlink"
-    );
-    
-    /**
-     * 危险的内置函数
-     */
-    private static final Set<String> DANGEROUS_BUILTINS = Set.of(
-            "exec",          // 执行代码
-            "eval",          // 评估表达式
-            "compile",       // 编译代码
-            "__import__"     // 动态导入
-    );
-    
-    /**
-     * 检查代码安全性
-     * @param code Python 代码
-     * @return 安全检查结果
-     */
-    public static SecurityCheckResult check(String code) {
-        if (code == null || code.trim().isEmpty()) {
-            return SecurityCheckResult.fail("代码为空");
-        }
-        
-        List<String> violations = new ArrayList<>();
-        
-        // 1. 检查危险导入
-        for (String module : DANGEROUS_IMPORTS) {
-            if (containsImport(code, module)) {
-                violations.add("禁止导入危险模块: " + module);
-            }
-        }
-        
-        // 2. 检查危险的 os 方法调用
-        for (String method : DANGEROUS_OS_METHODS) {
-            if (containsOsMethodCall(code, method)) {
-                violations.add("禁止使用危险的 os 方法: os." + method + "()");
-            }
-        }
-        
-        // 3. 检查危险的内置函数
-        for (String builtin : DANGEROUS_BUILTINS) {
-            if (containsBuiltinCall(code, builtin)) {
-                violations.add("禁止使用危险的内置函数: " + builtin + "()");
-            }
-        }
-        
-        // 4. 检查危险的文件操作模式
-        if (containsDangerousFileOperation(code)) {
-            violations.add("禁止使用危险的文件写入操作");
-        }
-        
-        if (violations.isEmpty()) {
-            return SecurityCheckResult.pass();
-        } else {
-            return SecurityCheckResult.fail(String.join("; ", violations));
-        }
-    }
-    
-    /**
-     * 检查是否包含指定模块的导入
-     */
-    private static boolean containsImport(String code, String module) {
-        // 匹配: import module / from module import xxx
-        String pattern1 = "(?m)^\\s*import\\s+" + Pattern.quote(module) + "\\b";
-        String pattern2 = "(?m)^\\s*from\\s+" + Pattern.quote(module) + "\\s+import";
-        
-        return Pattern.compile(pattern1).matcher(code).find() ||
-               Pattern.compile(pattern2).matcher(code).find();
-    }
-    
-    /**
-     * 检查是否包含指定的 os 方法调用
-     */
-    private static boolean containsOsMethodCall(String code, String method) {
-        // 匹配: os.method(
-        String pattern = "\\bos\\s*\\.\\s*" + Pattern.quote(method) + "\\s*\\(";
-        return Pattern.compile(pattern).matcher(code).find();
-    }
-    
-    /**
-     * 检查是否包含指定的内置函数调用
-     */
-    private static boolean containsBuiltinCall(String code, String builtin) {
-        // 匹配: builtin( 但排除方法调用 xxx.builtin(
-        String pattern = "(?<!\\.)\\b" + Pattern.quote(builtin) + "\\s*\\(";
-        return Pattern.compile(pattern).matcher(code).find();
-    }
-    
-    /**
-     * 检查是否包含危险的文件操作
-     */
-    private static boolean containsDangerousFileOperation(String code) {
-        // 检查 open() 的写入模式
-        Pattern openPattern = Pattern.compile("\\bopen\\s*\\([^)]*['\"][wax+]['\"]");
-        if (openPattern.matcher(code).find()) {
-            return true;
-        }
-        
-        // 检查直接的文件写入
-        Pattern writePattern = Pattern.compile("\\.write\\s*\\(|\\.writelines\\s*\\(");
-        if (writePattern.matcher(code).find()) {
-            // 需要进一步判断是否是文件写入而不是 response 写入等
-            // 这里简单处理，如果有 write 调用但没有 requests/http 相关的上下文，则禁止
-            if (!code.contains("requests") && !code.contains("http")) {
-                return true;
-            }
-        }
-        
-        return false;
-    }
-    
-    /**
-     * 安全检查结果
-     */
-    public static class SecurityCheckResult {
-        private final boolean passed;
-        private final String message;
-        
-        private SecurityCheckResult(boolean passed, String message) {
-            this.passed = passed;
-            this.message = message;
-        }
-        
-        public static SecurityCheckResult pass() {
-            return new SecurityCheckResult(true, null);
-        }
-        
-        public static SecurityCheckResult fail(String message) {
-            return new SecurityCheckResult(false, message);
-        }
-        
-        public boolean isPassed() {
-            return passed;
-        }
-        
-        public String getMessage() {
-            return message;
-        }
-        
-        @Override
-        public String toString() {
-            return passed ? "PASSED" : "FAILED: " + message;
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyContextPool.java

@@ -1,817 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Engine;
-import org.graalvm.polyglot.HostAccess;
-import org.graalvm.polyglot.Value;
-import org.graalvm.polyglot.io.IOAccess;
-import org.graalvm.python.embedding.utils.GraalPyResources;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.List;
-import java.util.ArrayList;
-
-/**
- * GraalPy Context 池化管理器
- * 提供共享的 Engine 实例和 Context 池化支持
- * 支持真正的 pip 包（如 requests）
- * 
- * <p>特性：
- * <ul>
- *   <li>共享单个 Engine 实例，减少内存占用和启动时间</li>
- *   <li>Context 对象池，避免重复创建和销毁的开销</li>
- *   <li>支持真正的 pip 包（通过 GraalPy Resources）</li>
- *   <li>支持安全的沙箱配置</li>
- *   <li>线程安全的池化管理</li>
- *   <li>支持优雅关闭和资源清理</li>
- *   <li>路径缓存，避免重复检测文件系统</li>
- *   <li>预热机制，在后台预导入常用模块</li>
- * </ul>
- * 
- * @author QAIU
- */
-public class PyContextPool {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyContextPool.class);
-    
-    // 池化配置 - 增加初始池大小和延长生命周期
-    private static final int INITIAL_POOL_SIZE = 4;
-    private static final int MAX_POOL_SIZE = 10;
-    private static final long CONTEXT_TIMEOUT_MS = 30000; // 30秒获取超时
-    private static final long CONTEXT_MAX_AGE_MS = 900000; // 15分钟最大使用时间
-    
-    // 路径缓存 - 避免重复检测文件系统
-    private static volatile List<String> cachedValidPaths = null;
-    private static final Object PATH_CACHE_LOCK = new Object();
-    
-    // 单例实例
-    private static volatile PyContextPool instance;
-    private static final Object LOCK = new Object();
-    
-    // 共享的GraalPy引擎
-    private final Engine sharedEngine;
-    
-    // Context 池
-    private final BlockingQueue<PooledContext> contextPool;
-    
-    // 已创建的Context数量
-    private final AtomicInteger createdCount = new AtomicInteger(0);
-    
-    // 是否已关闭
-    private final AtomicBoolean closed = new AtomicBoolean(false);
-    
-    // 定期清理过期Context的调度器
-    private final ScheduledExecutorService cleanupScheduler;
-    
-    // Python执行专用线程池
-    private final ExecutorService pythonExecutor;
-    
-    // 超时调度器
-    private final ScheduledExecutorService timeoutScheduler;
-    
-    /**
-     * 池化的Context包装器
-     */
-    public static class PooledContext implements AutoCloseable {
-        private final Context context;
-        private final long createdTime;
-        private final PyContextPool pool;
-        private volatile boolean inUse = false;
-        private volatile long lastUsedTime;
-        
-        private PooledContext(Context context, PyContextPool pool) {
-            this.context = context;
-            this.pool = pool;
-            this.createdTime = System.currentTimeMillis();
-            this.lastUsedTime = createdTime;
-        }
-        
-        /**
-         * 获取底层Context
-         */
-        public Context getContext() {
-            return context;
-        }
-        
-        /**
-         * 检查是否过期
-         */
-        public boolean isExpired() {
-            return System.currentTimeMillis() - createdTime > CONTEXT_MAX_AGE_MS;
-        }
-        
-        /**
-         * 归还到池中或关闭
-         */
-        @Override
-        public void close() {
-            pool.release(this);
-        }
-        
-        /**
-         * 强制关闭Context
-         */
-        void forceClose() {
-            try {
-                context.close(true);
-            } catch (Exception e) {
-                log.warn("关闭Context失败: {}", e.getMessage());
-            }
-        }
-        
-        /**
-         * 重置Context状态（清除绑定等）
-         */
-        boolean reset() {
-            try {
-                // 由于GraalPy的Context不能很好地重置状态，
-                // 简单场景下我们选择创建新的Context
-                // 但对于短生命周期的执行，可以尝试继续使用
-                lastUsedTime = System.currentTimeMillis();
-                return !isExpired();
-            } catch (Exception e) {
-                log.warn("重置Context失败: {}", e.getMessage());
-                return false;
-            }
-        }
-    }
-    
-    /**
-     * 私有构造函数
-     */
-    private PyContextPool() {
-        log.info("初始化GraalPy Context池...");
-        
-        // 创建共享Engine - 使用标准Polyglot API
-        Engine engine = null;
-        try {
-            engine = Engine.newBuilder()
-                    .option("engine.WarnInterpreterOnly", "false")
-                    .build();
-            
-            // 验证Python语言是否可用
-            if (!engine.getLanguages().containsKey("python")) {
-                throw new IllegalStateException("Python语言不可用，请检查GraalPy依赖配置");
-            }
-            log.info("Engine创建成功，可用语言: {}", engine.getLanguages().keySet());
-        } catch (Exception e) {
-            log.error("创建Engine失败: {}", e.getMessage());
-            checkGraalPyAvailability();
-            throw new RuntimeException("无法初始化GraalPy Engine，请确保GraalPy依赖正确配置", e);
-        }
-        this.sharedEngine = engine;
-        
-        // 创建Context池
-        this.contextPool = new LinkedBlockingQueue<>(MAX_POOL_SIZE);
-        
-        // 创建Python执行专用线程池
-        this.pythonExecutor = Executors.newCachedThreadPool(r -> {
-            Thread thread = new Thread(r);
-            thread.setName("py-context-pool-worker-" + System.currentTimeMillis());
-            thread.setDaemon(true);
-            return thread;
-        });
-        
-        // 创建超时调度器
-        this.timeoutScheduler = Executors.newScheduledThreadPool(2, r -> {
-            Thread thread = new Thread(r);
-            thread.setName("py-context-timeout-" + System.currentTimeMillis());
-            thread.setDaemon(true);
-            return thread;
-        });
-        
-        // 创建清理调度器
-        this.cleanupScheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-            Thread thread = new Thread(r);
-            thread.setName("py-context-cleanup");
-            thread.setDaemon(true);
-            return thread;
-        });
-        
-        // 预热：初始化一些Context
-        warmup();
-        
-        // 定期清理过期的Context
-        cleanupScheduler.scheduleWithFixedDelay(this::cleanup, 60, 60, TimeUnit.SECONDS);
-        
-        log.info("GraalPy Context池初始化完成，初始大小: {}", INITIAL_POOL_SIZE);
-    }
-    
-    /**
-     * 获取单例实例
-     */
-    public static PyContextPool getInstance() {
-        if (instance == null) {
-            synchronized (LOCK) {
-                if (instance == null) {
-                    instance = new PyContextPool();
-                }
-            }
-        }
-        return instance;
-    }
-    
-    /**
-     * 获取共享Engine
-     */
-    public Engine getSharedEngine() {
-        return sharedEngine;
-    }
-    
-    /**
-     * 获取Python执行线程池
-     */
-    public ExecutorService getPythonExecutor() {
-        return pythonExecutor;
-    }
-    
-    /**
-     * 获取超时调度器
-     */
-    public ScheduledExecutorService getTimeoutScheduler() {
-        return timeoutScheduler;
-    }
-    
-    /**
-     * 预热Context池
-     * 在后台线程中预创建 Context 并预导入常用模块
-     */
-    private void warmup() {
-        log.info("开始预热 Context 池，目标数量: {}", INITIAL_POOL_SIZE);
-        
-        // 使用线程池并行预热
-        for (int i = 0; i < INITIAL_POOL_SIZE; i++) {
-            final int index = i;
-            pythonExecutor.submit(() -> {
-                try {
-                    long start = System.currentTimeMillis();
-                    PooledContext pc = createPooledContext();
-                    
-                    // 预导入 requests 模块（主要耗时点）
-                    try {
-                        warmupContext(pc.getContext());
-                    } catch (Exception e) {
-                        log.debug("预热 Context {} 导入模块失败（非首个Context的NativeModules限制）: {}", 
-                                index, e.getMessage());
-                    }
-                    
-                    if (!contextPool.offer(pc)) {
-                        pc.forceClose();
-                    } else {
-                        long elapsed = System.currentTimeMillis() - start;
-                        log.info("预热 Context {} 完成，耗时: {}ms", index, elapsed);
-                    }
-                } catch (Exception e) {
-                    log.warn("预热 Context {} 失败: {}", index, e.getMessage());
-                }
-            });
-        }
-    }
-    
-    /**
-     * 预热单个 Context - 预导入常用模块
-     */
-    private void warmupContext(Context context) {
-        String warmupScript = """
-            # 预导入常用模块
-            import json
-            import re
-            import base64
-            import hashlib
-            import urllib.parse
-            
-            # 尝试导入 requests（可能因 NativeModules 限制失败）
-            try:
-                import requests
-            except (ImportError, SystemError):
-                pass
-            """;
-        context.eval("python", warmupScript);
-    }
-    
-    /**
-     * 创建新的池化Context
-     * 使用 GraalPyResources 支持 pip 包
-     */
-    private PooledContext createPooledContext() {
-        if (closed.get()) {
-            throw new IllegalStateException("Context池已关闭");
-        }
-        
-        Context context;
-        try {
-            // 检查 VFS 资源是否存在
-            var vfsResource = getClass().getClassLoader().getResource("org.graalvm.python.vfs/venv");
-            log.info("GraalPy VFS资源检查: venv={}", vfsResource != null ? "存在" : "不存在");
-            
-            // 使用 GraalPyResources 创建支持 pip 包的 Context
-            // 注意：不传入共享 Engine，让 GraalPyResources 管理自己的 Engine
-            log.info("正在创建 GraalPyResources Context...");
-            context = GraalPyResources.contextBuilder()
-                    .allowHostAccess(HostAccess.newBuilder(HostAccess.EXPLICIT)
-                            .allowArrayAccess(true)
-                            .allowListAccess(true)
-                            .allowMapAccess(true)
-                            .allowIterableAccess(true)
-                            .allowIteratorAccess(true)
-                            .build())
-                    .allowExperimentalOptions(true)
-                    .allowCreateThread(true)
-                    // 允许 IO 以支持 pip 包加载和网络请求
-                    .allowIO(IOAccess.ALL)
-                    .allowNativeAccess(true)
-                    .option("engine.WarnInterpreterOnly", "false")
-                    .build();
-            log.info("GraalPyResources Context 创建成功");
-            
-            // 配置 Python 路径
-            setupPythonPath(context);
-            
-        } catch (Exception e) {
-            log.error("使用GraalPyResources创建Context失败: {}", e.getMessage(), e);
-            throw new RuntimeException("无法创建支持pip包的Python Context: " + e.getMessage(), e);
-        }
-        
-        createdCount.incrementAndGet();
-        log.debug("创建新的GraalPy Context，当前总数: {}", createdCount.get());
-        
-        return new PooledContext(context, this);
-    }
-    
-    /**
-     * 从池中获取Context
-     * 
-     * @return 池化的Context，用完后需要调用close()归还
-     * @throws InterruptedException 如果等待被中断
-     * @throws TimeoutException 如果超时未获取到
-     */
-    public PooledContext acquire() throws InterruptedException, TimeoutException {
-        if (closed.get()) {
-            throw new IllegalStateException("Context池已关闭");
-        }
-        
-        // 尝试从池中获取
-        PooledContext pc = contextPool.poll();
-        
-        if (pc != null) {
-            if (!pc.isExpired() && pc.reset()) {
-                pc.inUse = true;
-                log.debug("从池中获取Context，池剩余: {}", contextPool.size());
-                return pc;
-            } else {
-                // Context已过期，关闭它
-                pc.forceClose();
-                createdCount.decrementAndGet();
-            }
-        }
-        
-        // 池中没有可用的，检查是否可以创建新的
-        if (createdCount.get() < MAX_POOL_SIZE) {
-            try {
-                pc = createPooledContext();
-                pc.inUse = true;
-                return pc;
-            } catch (Exception e) {
-                log.error("创建新Context失败: {}", e.getMessage());
-                throw new RuntimeException("无法创建GraalPy Context", e);
-            }
-        }
-        
-        // 已达最大数量，等待归还
-        pc = contextPool.poll(CONTEXT_TIMEOUT_MS, TimeUnit.MILLISECONDS);
-        if (pc == null) {
-            throw new TimeoutException("获取GraalPy Context超时");
-        }
-        
-        if (!pc.isExpired() && pc.reset()) {
-            pc.inUse = true;
-            return pc;
-        } else {
-            pc.forceClose();
-            createdCount.decrementAndGet();
-            // 递归重试
-            return acquire();
-        }
-    }
-    
-    /**
-     * 创建一个新的非池化Context（用于需要独立生命周期的场景）
-     * 调用者负责管理其生命周期
-     * 支持真正的 pip 包（如 requests, zlib 等）
-     * 
-     * 注意：GraalPyResources 需要独立的 Engine，不能与共享 Engine 一起使用
-     */
-    public Context createFreshContext() {
-        try {
-            // 检查 VFS 资源是否存在
-            var vfsResource = getClass().getClassLoader().getResource("org.graalvm.python.vfs/venv");
-            var homeResource = getClass().getClassLoader().getResource("org.graalvm.python.vfs/home");
-            log.info("GraalPy VFS资源检查: venv={}, home={}", 
-                    vfsResource != null ? "存在" : "不存在",
-                    homeResource != null ? "存在" : "不存在");
-            
-            // 使用 GraalPyResources 创建支持 pip 包的 Context
-            // 注意：不传入共享 Engine，让 GraalPyResources 管理自己的 Engine
-            log.info("正在创建 GraalPyResources FreshContext...");
-            Context ctx = GraalPyResources.contextBuilder()
-                    .allowHostAccess(HostAccess.newBuilder(HostAccess.EXPLICIT)
-                            .allowArrayAccess(true)
-                            .allowListAccess(true)
-                            .allowMapAccess(true)
-                            .allowIterableAccess(true)
-                            .allowIteratorAccess(true)
-                            .build())
-                    .allowExperimentalOptions(true)
-                    .allowCreateThread(true)
-                    // 允许 IO 以支持 pip 包加载和网络请求
-                    .allowIO(IOAccess.ALL)
-                    .allowNativeAccess(true)
-                    .option("engine.WarnInterpreterOnly", "false")
-                    .build();
-            log.info("GraalPyResources FreshContext 创建成功");
-            
-            // 手动配置 Python 路径以加载 VFS 中的 pip 包
-            setupPythonPath(ctx);
-            
-            return ctx;
-        } catch (Exception e) {
-            log.error("使用GraalPyResources创建Context失败: {}", e.getMessage(), e);
-            throw new RuntimeException("无法创建支持pip包的Python Context: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * 配置 Python 路径，确保能够加载 pip 包
-     * 使用路径缓存机制，避免重复检测文件系统
-     * 
-     * pip 包安装来源：
-     * 1. Maven 构建时 graalpy-maven-plugin 自动安装 requests 等核心包到
-     *    target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages/
-     * 2. 可选：运行 parser/setup-graalpy-packages.sh 安装 python-lsp-server（Playground 代码提示）
-     * 
-     * 注意：GraalPy 的 NativeModules 限制 - 只有进程中的第一个 Context 可以使用原生模块。
-     * 后续 Context 会回退到 LLVM 模式，这可能导致某些依赖原生模块的库无法正常工作。
-     */
-    private void setupPythonPath(Context context) {
-        try {
-            log.debug("配置 Python 环境...");
-            
-            // 使用缓存的有效路径
-            List<String> validPaths = getValidPythonPaths();
-            
-            if (validPaths.isEmpty()) {
-                log.warn("未找到有效的 Python 包路径");
-                return;
-            }
-            
-            // 构建添加路径的脚本 - 使用已验证的路径，跳过文件系统检测
-            StringBuilder pathsJson = new StringBuilder("[");
-            boolean first = true;
-            for (String path : validPaths) {
-                if (!first) pathsJson.append(", ");
-                first = false;
-                pathsJson.append("'").append(path.replace("\\", "/").replace("'", "\\'")).append("'");
-            }
-            pathsJson.append("]");
-            
-            // 简化的路径添加脚本 - 不再调用 os.path.isdir，直接添加已验证的路径
-            String addPathScript = String.format("""
-                import sys
-                
-                _paths_to_add = %s
-                _added_paths = []
-                for path in _paths_to_add:
-                    if path not in sys.path:
-                        sys.path.insert(0, path)
-                        _added_paths.append(path)
-                
-                _added_paths_str = ', '.join(_added_paths) if _added_paths else ''
-                """, pathsJson);
-            
-            context.eval("python", addPathScript);
-            Value bindings = context.getBindings("python");
-            String addedPaths = bindings.getMember("_added_paths_str").asString();
-            
-            if (!addedPaths.isEmpty()) {
-                log.debug("添加的 Python 路径: {}", addedPaths);
-            }
-            
-            // 验证 requests 是否可用（简化版，不阻塞）
-            // 注意：在多 Context 环境中，可能因 NativeModules 限制而失败
-            String verifyScript = """
-                import sys
-                
-                _requests_available = False
-                _requests_version = ''
-                _error_msg = ''
-                _native_module_error = False
-                
-                try:
-                    import requests
-                    _requests_available = True
-                    _requests_version = requests.__version__
-                except SystemError as e:
-                    # NativeModules 冲突 - GraalPy 限制
-                    _error_msg = str(e)
-                    if 'NativeModules' in _error_msg or 'llvm' in _error_msg:
-                        _native_module_error = True
-                except ImportError as e:
-                    _error_msg = str(e)
-                
-                _sys_path_length = len(sys.path)
-                """;
-            
-            context.eval("python", verifyScript);
-            
-            boolean requestsAvailable = bindings.getMember("_requests_available").asBoolean();
-            boolean nativeModuleError = bindings.getMember("_native_module_error").asBoolean();
-            int pathLength = bindings.getMember("_sys_path_length").asInt();
-            
-            if (requestsAvailable) {
-                String version = bindings.getMember("_requests_version").asString();
-                log.info("Python 环境配置完成: requests {} 可用, sys.path长度: {}", version, pathLength);
-            } else if (nativeModuleError) {
-                // GraalPy 的 NativeModules 限制 - 这是已知限制，不是配置错误
-                log.debug("Python 环境配置: requests 因 NativeModules 限制不可用 (非首个 Context). " +
-                        "这是 GraalPy 的已知限制，标准库仍可正常使用。");
-            } else {
-                String error = bindings.getMember("_error_msg").asString();
-                log.warn("Python 环境配置: requests 不可用 ({}), sys.path长度: {}. " +
-                        "检查 Maven 构建是否正常完成 (graalpy-maven-plugin)", error, pathLength);
-            }
-            
-        } catch (Exception e) {
-            String msg = e.getMessage();
-            // 检查是否是 NativeModules 相关的错误
-            if (msg != null && (msg.contains("NativeModules") || msg.contains("llvm"))) {
-                log.debug("Python 环境配置: 因 NativeModules 限制跳过 requests 验证 (非首个 Context)");
-            } else {
-                log.warn("Python 环境配置失败，继续使用默认配置: {}", msg);
-            }
-            // 不抛出异常，允许 Context 继续使用
-        }
-    }
-    
-    /**
-     * 设置安全的 OS 模块限制
-     * 只允许安全的读取操作，禁止危险的文件系统操作
-     * 
-     * 注意：此方法应在所有必要的库导入完成后调用，
-     * 因为替换 os 模块会影响依赖它的库（如 requests）
-     */
-    private void setupSecureOsModule(Context context) {
-        // 此方法当前禁用，因为会影响 requests 库的正常工作
-        // 安全限制将在代码执行层面实现，而不是替换系统模块
-        log.debug("OS 模块安全策略：通过代码审查实现，不替换系统模块");
-    }
-    
-    /**
-     * 获取有效的 Python 包路径（带缓存）
-     * 首次调用时检测文件系统，后续直接返回缓存
-     */
-    private List<String> getValidPythonPaths() {
-        if (cachedValidPaths != null) {
-            return cachedValidPaths;
-        }
-        
-        synchronized (PATH_CACHE_LOCK) {
-            if (cachedValidPaths != null) {
-                return cachedValidPaths;
-            }
-            
-            log.debug("首次检测 Python 包路径...");
-            long start = System.currentTimeMillis();
-            
-            List<String> validPaths = new ArrayList<>();
-            String userDir = System.getProperty("user.dir");
-            
-            // 尝试从 classpath 获取 graalpy-packages 路径
-            String classpathPackages = null;
-            try {
-                var resource = getClass().getClassLoader().getResource("graalpy-packages");
-                if (resource != null) {
-                    classpathPackages = resource.getPath();
-                    // 处理 jar 内路径
-                    if (classpathPackages.contains("!")) {
-                        classpathPackages = null; // jar 内无法直接作为文件系统路径
-                    }
-                }
-            } catch (Exception e) {
-                log.debug("无法从 classpath 获取 graalpy-packages: {}", e.getMessage());
-            }
-            
-            // 可能的 pip 包路径列表
-            String[] possiblePaths = {
-                classpathPackages,
-                userDir + "/resources/graalpy-packages",
-                userDir + "/src/main/resources/graalpy-packages",
-                userDir + "/parser/src/main/resources/graalpy-packages",
-                userDir + "/target/classes/graalpy-packages",
-                userDir + "/parser/target/classes/graalpy-packages",
-                userDir + "/graalpy-venv/lib/python3.11/site-packages",
-                userDir + "/parser/graalpy-venv/lib/python3.11/site-packages",
-            };
-            
-            // 检测有效路径
-            for (String path : possiblePaths) {
-                if (path != null) {
-                    java.io.File dir = new java.io.File(path);
-                    if (dir.isDirectory()) {
-                        validPaths.add(path);
-                    }
-                }
-            }
-            
-            long elapsed = System.currentTimeMillis() - start;
-            log.info("Python 包路径检测完成，耗时: {}ms，有效路径数: {}", elapsed, validPaths.size());
-            if (!validPaths.isEmpty()) {
-                log.debug("有效路径: {}", validPaths);
-            }
-            
-            cachedValidPaths = validPaths;
-            return validPaths;
-        }
-    }
-    
-    /**
-     * 安全策略说明：
-     * 
-     * 由于 requests 等第三方库内部会使用 os 模块的功能，
-     * 直接替换 os 模块会导致这些库无法正常工作。
-     * 
-     * 因此，安全控制通过以下方式实现：
-     * 1. 代码静态检查（在执行前扫描危险的 os.system 等调用）
-     * 2. 在 PyPlaygroundExecutor 中对用户代码进行预处理
-     * 3. 使用 GraalPy 的沙箱机制限制文件系统访问
-     * 
-     * 禁止的操作：
-     * - os.system(), os.popen() - 系统命令执行
-     * - os.remove(), os.unlink(), os.rmdir() - 文件删除
-     * - os.mkdir(), os.makedirs() - 目录创建
-     * - subprocess.* - 子进程操作
-     * 
-     * 允许的操作：
-     * - requests.* - HTTP 请求
-     * - os.path.* - 路径操作（只读）
-     * - os.getcwd() - 获取当前目录
-     * - json, re, base64, hashlib 等标准库
-     */
-    
-    /**
-     * 归还Context到池中
-     */
-    private void release(PooledContext pc) {
-        if (pc == null) return;
-        
-        pc.inUse = false;
-        
-        if (closed.get() || pc.isExpired()) {
-            // 池已关闭或Context已过期，直接销毁
-            pc.forceClose();
-            createdCount.decrementAndGet();
-            log.debug("Context已过期或池已关闭，销毁Context");
-        } else if (!contextPool.offer(pc)) {
-            // 池已满，销毁Context
-            pc.forceClose();
-            createdCount.decrementAndGet();
-            log.debug("池已满，销毁多余Context");
-        } else {
-            log.debug("归还Context到池，池当前大小: {}", contextPool.size());
-        }
-    }
-    
-    /**
-     * 清理过期的Context
-     */
-    private void cleanup() {
-        if (closed.get()) return;
-        
-        int removed = 0;
-        PooledContext pc;
-        
-        while ((pc = contextPool.poll()) != null) {
-            if (pc.isExpired() || closed.get()) {
-                pc.forceClose();
-                createdCount.decrementAndGet();
-                removed++;
-            } else {
-                // 还没过期，放回池中
-                if (!contextPool.offer(pc)) {
-                    pc.forceClose();
-                    createdCount.decrementAndGet();
-                    removed++;
-                }
-                break;
-            }
-        }
-        
-        if (removed > 0) {
-            log.info("清理了 {} 个过期的Context，当前池大小: {}", removed, contextPool.size());
-        }
-    }
-    
-    /**
-     * 获取池状态信息
-     */
-    public String getStatus() {
-        return String.format("PyContextPool[total=%d, available=%d, maxSize=%d]",
-                createdCount.get(), contextPool.size(), MAX_POOL_SIZE);
-    }
-    
-    /**
-     * 获取池中可用的Context数量
-     */
-    public int getAvailableCount() {
-        return contextPool.size();
-    }
-    
-    /**
-     * 获取已创建的Context总数
-     */
-    public int getCreatedCount() {
-        return createdCount.get();
-    }
-    
-    /**
-     * 检查GraalPy是否可用
-     */
-    private void checkGraalPyAvailability() {
-        log.error("===== GraalPy 可用性检查 =====");
-        
-        // 检查类路径
-        try {
-            Class.forName("org.graalvm.polyglot.Engine");
-            log.info("✓ org.graalvm.polyglot.Engine 类存在");
-        } catch (ClassNotFoundException e) {
-            log.error("✗ org.graalvm.polyglot.Engine 类不存在");
-        }
-        
-        try {
-            Class.forName("org.graalvm.python.embedding.GraalPyResources");
-            log.info("✓ org.graalvm.python.embedding.GraalPyResources 类存在");
-        } catch (ClassNotFoundException e) {
-            log.warn("  python-embedding 类不存在（可选依赖）");
-        }
-        
-        // 尝试列出可用语言
-        try {
-            log.info("尝试使用标准 Polyglot API 创建 Context...");
-            try (Engine engine = Engine.create()) {
-                log.info("  可用语言: {}", engine.getLanguages().keySet());
-                if (engine.getLanguages().containsKey("python")) {
-                    log.info("✓ Python 语言可用");
-                } else {
-                    log.error("✗ Python 语言不可用");
-                }
-            }
-        } catch (Exception e) {
-            log.error("✗ 创建 Engine 失败: {}", e.getMessage());
-        }
-        
-        log.error("================================");
-        log.error("请检查以下依赖是否正确配置:");
-        log.error("  1. org.graalvm.polyglot:polyglot");
-        log.error("  2. org.graalvm.polyglot:python (type=pom)");
-        log.error("================================");
-    }
-    
-    /**
-     * 关闭Context池
-     */
-    public void shutdown() {
-        if (closed.compareAndSet(false, true)) {
-            log.info("关闭GraalPy Context池...");
-            
-            // 停止清理调度器
-            cleanupScheduler.shutdownNow();
-            timeoutScheduler.shutdownNow();
-            pythonExecutor.shutdownNow();
-            
-            // 关闭所有池中的Context
-            PooledContext pc;
-            while ((pc = contextPool.poll()) != null) {
-                pc.forceClose();
-            }
-            
-            // 关闭共享Engine
-            try {
-                sharedEngine.close(true);
-            } catch (Exception e) {
-                log.warn("关闭共享Engine失败: {}", e.getMessage());
-            }
-            
-            log.info("GraalPy Context池已关闭");
-        }
-    }
-    
-    /**
-     * 检查池是否已关闭
-     */
-    public boolean isClosed() {
-        return closed.get();
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyCryptoUtils.java

@@ -1,381 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.HostAccess;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.crypto.Cipher;
-import javax.crypto.spec.IvParameterSpec;
-import javax.crypto.spec.SecretKeySpec;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.util.Base64;
-
-/**
- * Python加密工具类
- * 为Python脚本提供常用的加密解密功能
- *
- * @author QAIU
- */
-public class PyCryptoUtils {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyCryptoUtils.class);
-    
-    // ==================== MD5 ====================
-    
-    /**
-     * MD5加密（返回32位小写）
-     * @param data 待加密数据
-     * @return MD5值（32位小写）
-     */
-    @HostAccess.Export
-    public String md5(String data) {
-        if (data == null) {
-            return null;
-        }
-        try {
-            MessageDigest md = MessageDigest.getInstance("MD5");
-            byte[] digest = md.digest(data.getBytes(StandardCharsets.UTF_8));
-            return bytesToHex(digest);
-        } catch (Exception e) {
-            log.error("MD5加密失败", e);
-            throw new RuntimeException("MD5加密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * MD5加密（返回16位小写，取中间16位）
-     * @param data 待加密数据
-     * @return MD5值（16位小写）
-     */
-    @HostAccess.Export
-    public String md5_16(String data) {
-        String md5 = md5(data);
-        return md5 != null ? md5.substring(8, 24) : null;
-    }
-    
-    // ==================== SHA ====================
-    
-    /**
-     * SHA-1加密
-     * @param data 待加密数据
-     * @return SHA-1值（小写）
-     */
-    @HostAccess.Export
-    public String sha1(String data) {
-        return sha(data, "SHA-1");
-    }
-    
-    /**
-     * SHA-256加密
-     * @param data 待加密数据
-     * @return SHA-256值（小写）
-     */
-    @HostAccess.Export
-    public String sha256(String data) {
-        return sha(data, "SHA-256");
-    }
-    
-    /**
-     * SHA-512加密
-     * @param data 待加密数据
-     * @return SHA-512值（小写）
-     */
-    @HostAccess.Export
-    public String sha512(String data) {
-        return sha(data, "SHA-512");
-    }
-    
-    private String sha(String data, String algorithm) {
-        if (data == null) {
-            return null;
-        }
-        try {
-            MessageDigest md = MessageDigest.getInstance(algorithm);
-            byte[] digest = md.digest(data.getBytes(StandardCharsets.UTF_8));
-            return bytesToHex(digest);
-        } catch (Exception e) {
-            log.error(algorithm + "加密失败", e);
-            throw new RuntimeException(algorithm + "加密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    // ==================== Base64 ====================
-    
-    /**
-     * Base64编码
-     * @param data 待编码数据
-     * @return Base64字符串
-     */
-    @HostAccess.Export
-    public String base64_encode(String data) {
-        if (data == null) {
-            return null;
-        }
-        return Base64.getEncoder().encodeToString(data.getBytes(StandardCharsets.UTF_8));
-    }
-    
-    /**
-     * Base64编码（字节数组）
-     * @param data 待编码字节数组
-     * @return Base64字符串
-     */
-    @HostAccess.Export
-    public String base64_encode_bytes(byte[] data) {
-        if (data == null) {
-            return null;
-        }
-        return Base64.getEncoder().encodeToString(data);
-    }
-    
-    /**
-     * Base64解码
-     * @param data Base64字符串
-     * @return 解码后的字符串
-     */
-    @HostAccess.Export
-    public String base64_decode(String data) {
-        if (data == null) {
-            return null;
-        }
-        try {
-            byte[] decoded = Base64.getDecoder().decode(data);
-            return new String(decoded, StandardCharsets.UTF_8);
-        } catch (Exception e) {
-            log.error("Base64解码失败", e);
-            throw new RuntimeException("Base64解码失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * Base64解码（返回字节数组）
-     * @param data Base64字符串
-     * @return 解码后的字节数组
-     */
-    @HostAccess.Export
-    public byte[] base64_decode_bytes(String data) {
-        if (data == null) {
-            return null;
-        }
-        try {
-            return Base64.getDecoder().decode(data);
-        } catch (Exception e) {
-            log.error("Base64解码失败", e);
-            throw new RuntimeException("Base64解码失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * URL安全的Base64编码
-     * @param data 待编码数据
-     * @return URL安全的Base64字符串
-     */
-    @HostAccess.Export
-    public String base64_url_encode(String data) {
-        if (data == null) {
-            return null;
-        }
-        return Base64.getUrlEncoder().encodeToString(data.getBytes(StandardCharsets.UTF_8));
-    }
-    
-    /**
-     * URL安全的Base64解码
-     * @param data URL安全的Base64字符串
-     * @return 解码后的字符串
-     */
-    @HostAccess.Export
-    public String base64_url_decode(String data) {
-        if (data == null) {
-            return null;
-        }
-        try {
-            byte[] decoded = Base64.getUrlDecoder().decode(data);
-            return new String(decoded, StandardCharsets.UTF_8);
-        } catch (Exception e) {
-            log.error("Base64 URL解码失败", e);
-            throw new RuntimeException("Base64 URL解码失败: " + e.getMessage(), e);
-        }
-    }
-    
-    // ==================== AES ====================
-    
-    /**
-     * AES加密（ECB模式，PKCS5Padding）
-     * @param data 待加密数据
-     * @param key 密钥（16/24/32字节）
-     * @return Base64编码的密文
-     */
-    @HostAccess.Export
-    public String aes_encrypt_ecb(String data, String key) {
-        if (data == null || key == null) {
-            return null;
-        }
-        try {
-            SecretKeySpec secretKey = new SecretKeySpec(padKey(key), "AES");
-            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
-            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
-            byte[] encrypted = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
-            return Base64.getEncoder().encodeToString(encrypted);
-        } catch (Exception e) {
-            log.error("AES ECB加密失败", e);
-            throw new RuntimeException("AES ECB加密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * AES解密（ECB模式，PKCS5Padding）
-     * @param data Base64编码的密文
-     * @param key 密钥（16/24/32字节）
-     * @return 明文
-     */
-    @HostAccess.Export
-    public String aes_decrypt_ecb(String data, String key) {
-        if (data == null || key == null) {
-            return null;
-        }
-        try {
-            SecretKeySpec secretKey = new SecretKeySpec(padKey(key), "AES");
-            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
-            cipher.init(Cipher.DECRYPT_MODE, secretKey);
-            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(data));
-            return new String(decrypted, StandardCharsets.UTF_8);
-        } catch (Exception e) {
-            log.error("AES ECB解密失败", e);
-            throw new RuntimeException("AES ECB解密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * AES加密（CBC模式，PKCS5Padding）
-     * @param data 待加密数据
-     * @param key 密钥（16/24/32字节）
-     * @param iv 初始向量（16字节）
-     * @return Base64编码的密文
-     */
-    @HostAccess.Export
-    public String aes_encrypt_cbc(String data, String key, String iv) {
-        if (data == null || key == null || iv == null) {
-            return null;
-        }
-        try {
-            SecretKeySpec secretKey = new SecretKeySpec(padKey(key), "AES");
-            IvParameterSpec ivSpec = new IvParameterSpec(padIv(iv));
-            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
-            cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
-            byte[] encrypted = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
-            return Base64.getEncoder().encodeToString(encrypted);
-        } catch (Exception e) {
-            log.error("AES CBC加密失败", e);
-            throw new RuntimeException("AES CBC加密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    /**
-     * AES解密（CBC模式，PKCS5Padding）
-     * @param data Base64编码的密文
-     * @param key 密钥（16/24/32字节）
-     * @param iv 初始向量（16字节）
-     * @return 明文
-     */
-    @HostAccess.Export
-    public String aes_decrypt_cbc(String data, String key, String iv) {
-        if (data == null || key == null || iv == null) {
-            return null;
-        }
-        try {
-            SecretKeySpec secretKey = new SecretKeySpec(padKey(key), "AES");
-            IvParameterSpec ivSpec = new IvParameterSpec(padIv(iv));
-            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
-            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec);
-            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(data));
-            return new String(decrypted, StandardCharsets.UTF_8);
-        } catch (Exception e) {
-            log.error("AES CBC解密失败", e);
-            throw new RuntimeException("AES CBC解密失败: " + e.getMessage(), e);
-        }
-    }
-    
-    // ==================== Hex ====================
-    
-    /**
-     * 字节数组转十六进制字符串
-     * @param bytes 字节数组
-     * @return 十六进制字符串（小写）
-     */
-    @HostAccess.Export
-    public String bytes_to_hex(byte[] bytes) {
-        return bytesToHex(bytes);
-    }
-    
-    /**
-     * 十六进制字符串转字节数组
-     * @param hex 十六进制字符串
-     * @return 字节数组
-     */
-    @HostAccess.Export
-    public byte[] hex_to_bytes(String hex) {
-        if (hex == null || hex.length() % 2 != 0) {
-            return null;
-        }
-        int len = hex.length();
-        byte[] data = new byte[len / 2];
-        for (int i = 0; i < len; i += 2) {
-            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
-                    + Character.digit(hex.charAt(i + 1), 16));
-        }
-        return data;
-    }
-    
-    // ==================== 工具方法 ====================
-    
-    private static String bytesToHex(byte[] bytes) {
-        if (bytes == null) {
-            return null;
-        }
-        StringBuilder sb = new StringBuilder();
-        for (byte b : bytes) {
-            sb.append(String.format("%02x", b));
-        }
-        return sb.toString();
-    }
-    
-    /**
-     * 将密钥填充到16/24/32字节
-     */
-    private byte[] padKey(String key) {
-        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
-        int len = keyBytes.length;
-        
-        // 根据密钥长度决定填充到16/24/32字节
-        int targetLen;
-        if (len <= 16) {
-            targetLen = 16;
-        } else if (len <= 24) {
-            targetLen = 24;
-        } else {
-            targetLen = 32;
-        }
-        
-        if (len == targetLen) {
-            return keyBytes;
-        }
-        
-        byte[] paddedKey = new byte[targetLen];
-        System.arraycopy(keyBytes, 0, paddedKey, 0, Math.min(len, targetLen));
-        return paddedKey;
-    }
-    
-    /**
-     * 将IV填充到16字节
-     */
-    private byte[] padIv(String iv) {
-        byte[] ivBytes = iv.getBytes(StandardCharsets.UTF_8);
-        if (ivBytes.length == 16) {
-            return ivBytes;
-        }
-        
-        byte[] paddedIv = new byte[16];
-        System.arraycopy(ivBytes, 0, paddedIv, 0, Math.min(ivBytes.length, 16));
-        return paddedIv;
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyHttpClient.java

@@ -1,649 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.WebClientVertxInit;
-import cn.qaiu.util.HttpResponseHelper;
-import io.vertx.core.Future;
-import io.vertx.core.MultiMap;
-import io.vertx.core.Promise;
-import io.vertx.core.buffer.Buffer;
-import io.vertx.core.json.JsonObject;
-import io.vertx.core.net.ProxyOptions;
-import io.vertx.core.net.ProxyType;
-import io.vertx.ext.web.client.HttpRequest;
-import io.vertx.ext.web.client.HttpResponse;
-import io.vertx.ext.web.client.WebClient;
-import io.vertx.ext.web.client.WebClientOptions;
-import io.vertx.ext.web.client.WebClientSession;
-import io.vertx.ext.web.multipart.MultipartForm;
-import org.apache.commons.lang3.StringUtils;
-import org.graalvm.polyglot.HostAccess;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.net.InetAddress;
-import java.net.URI;
-import java.net.URLDecoder;
-import java.net.URLEncoder;
-import java.net.UnknownHostException;
-import java.nio.charset.StandardCharsets;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.regex.Pattern;
-
-/**
- * Python HTTP客户端封装
- * 为Python脚本提供类似requests库的HTTP请求功能
- * 基于Vert.x WebClient实现，提供同步API风格
- *
- * @author QAIU
- */
-public class PyHttpClient {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyHttpClient.class);
-    
-    private final WebClient client;
-    private final WebClientSession clientSession;
-    private MultiMap headers;
-    private int timeoutSeconds = 30; // 默认超时时间30秒
-    
-    // SSRF防护：内网IP正则表达式
-    private static final Pattern PRIVATE_IP_PATTERN = Pattern.compile(
-        "^(127\\..*|10\\..*|172\\.(1[6-9]|2[0-9]|3[01])\\..*|192\\.168\\..*|169\\.254\\..*|::1|[fF][cCdD].*)"
-    );
-    
-    // SSRF防护：危险域名黑名单
-    private static final String[] DANGEROUS_HOSTS = {
-        "localhost",
-        "169.254.169.254", // AWS/阿里云等云服务元数据API
-        "metadata.google.internal", // GCP元数据
-        "100.100.100.200" // 阿里云元数据
-    };
-    
-    public PyHttpClient() {
-        this.client = WebClient.create(WebClientVertxInit.get(), new WebClientOptions());
-        this.clientSession = WebClientSession.create(client);
-        this.headers = MultiMap.caseInsensitiveMultiMap();
-        initDefaultHeaders();
-    }
-    
-    /**
-     * 带代理配置的构造函数
-     * @param proxyConfig 代理配置JsonObject，包含type、host、port、username、password
-     */
-    public PyHttpClient(JsonObject proxyConfig) {
-        if (proxyConfig != null && proxyConfig.containsKey("type")) {
-            ProxyOptions proxyOptions = new ProxyOptions()
-                    .setType(ProxyType.valueOf(proxyConfig.getString("type").toUpperCase()))
-                    .setHost(proxyConfig.getString("host"))
-                    .setPort(proxyConfig.getInteger("port"));
-            
-            if (StringUtils.isNotEmpty(proxyConfig.getString("username"))) {
-                proxyOptions.setUsername(proxyConfig.getString("username"));
-            }
-            if (StringUtils.isNotEmpty(proxyConfig.getString("password"))) {
-                proxyOptions.setPassword(proxyConfig.getString("password"));
-            }
-            
-            this.client = WebClient.create(WebClientVertxInit.get(),
-                    new WebClientOptions()
-                            .setUserAgentEnabled(false)
-                            .setProxyOptions(proxyOptions));
-            this.clientSession = WebClientSession.create(client);
-        } else {
-            this.client = WebClient.create(WebClientVertxInit.get());
-            this.clientSession = WebClientSession.create(client);
-        }
-        this.headers = MultiMap.caseInsensitiveMultiMap();
-        initDefaultHeaders();
-    }
-    
-    private void initDefaultHeaders() {
-        // 设置默认的Accept-Encoding头以支持压缩响应
-        this.headers.set("Accept-Encoding", "gzip, deflate, br, zstd");
-        // 设置默认的User-Agent头
-        this.headers.set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0");
-        // 设置默认的Accept-Language头
-        this.headers.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6");
-    }
-    
-    /**
-     * 验证URL安全性（SSRF防护）- 仅拦截明显的内网攻击
-     * @param url 待验证的URL
-     * @throws SecurityException 如果URL不安全
-     */
-    private void validateUrlSecurity(String url) {
-        try {
-            URI uri = new URI(url);
-            String host = uri.getHost();
-            
-            if (host == null) {
-                log.debug("URL没有host信息: {}", url);
-                return;
-            }
-            
-            String lowerHost = host.toLowerCase();
-            
-            // 1. 检查明确的危险域名（云服务元数据API等）
-            for (String dangerous : DANGEROUS_HOSTS) {
-                if (lowerHost.equals(dangerous)) {
-                    log.warn("🔒 安全拦截: 尝试访问云服务元数据API - {}", host);
-                    throw new SecurityException("🔒 安全拦截: 禁止访问云服务元数据API");
-                }
-            }
-            
-            // 2. 如果host是IP地址格式，检查是否为内网IP
-            if (isIpAddress(lowerHost)) {
-                if (PRIVATE_IP_PATTERN.matcher(lowerHost).find()) {
-                    log.warn("🔒 安全拦截: 尝试访问内网IP - {}", host);
-                    throw new SecurityException("🔒 安全拦截: 禁止访问内网IP地址");
-                }
-            }
-            
-            // 3. 对于域名，尝试解析IP（但不因解析失败而拦截）
-            if (!isIpAddress(lowerHost)) {
-                try {
-                    InetAddress addr = InetAddress.getByName(host);
-                    String ip = addr.getHostAddress();
-                    
-                    if (PRIVATE_IP_PATTERN.matcher(ip).find()) {
-                        log.warn("🔒 安全拦截: 域名解析到内网IP - {} -> {}", host, ip);
-                        throw new SecurityException("🔒 安全拦截: 该域名指向内网地址");
-                    }
-                } catch (UnknownHostException e) {
-                    log.debug("DNS解析失败，允许继续: {}", host);
-                }
-            }
-            
-            log.debug("URL安全检查通过: {}", url);
-            
-        } catch (SecurityException e) {
-            throw e;
-        } catch (Exception e) {
-            log.debug("URL验证异常，允许继续: {}", url, e);
-        }
-    }
-    
-    /**
-     * 判断字符串是否为IP地址格式
-     */
-    private boolean isIpAddress(String host) {
-        return host.matches("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$") || host.contains(":");
-    }
-    
-    /**
-     * 发起GET请求
-     * @param url 请求URL
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse get(String url) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.getAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            return request.send();
-        });
-    }
-    
-    /**
-     * 发起GET请求并跟随重定向
-     * @param url 请求URL
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse get_with_redirect(String url) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.getAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            request.followRedirects(true);
-            return request.send();
-        });
-    }
-    
-    /**
-     * 发起GET请求但不跟随重定向（用于获取Location头）
-     * @param url 请求URL
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse get_no_redirect(String url) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.getAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            request.followRedirects(false);
-            return request.send();
-        });
-    }
-    
-    /**
-     * 发起POST请求
-     * @param url 请求URL
-     * @param data 请求数据（支持String、Map）
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse post(String url, Object data) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.postAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            
-            if (data != null) {
-                if (data instanceof String) {
-                    return request.sendBuffer(Buffer.buffer((String) data));
-                } else if (data instanceof Map) {
-                    @SuppressWarnings("unchecked")
-                    Map<String, String> mapData = (Map<String, String>) data;
-                    return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
-                } else {
-                    return request.sendJson(data);
-                }
-            } else {
-                return request.send();
-            }
-        });
-    }
-    
-    /**
-     * 发起POST请求（JSON数据）
-     * @param url 请求URL
-     * @param jsonData JSON字符串或Map
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse post_json(String url, Object jsonData) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.postAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            headers.set("Content-Type", "application/json");
-            
-            if (jsonData instanceof String) {
-                return request.sendBuffer(Buffer.buffer((String) jsonData));
-            } else {
-                return request.sendJson(jsonData);
-            }
-        });
-    }
-    
-    /**
-     * 发起PUT请求
-     * @param url 请求URL
-     * @param data 请求数据
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse put(String url, Object data) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.putAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            
-            if (data != null) {
-                if (data instanceof String) {
-                    return request.sendBuffer(Buffer.buffer((String) data));
-                } else if (data instanceof Map) {
-                    @SuppressWarnings("unchecked")
-                    Map<String, String> mapData = (Map<String, String>) data;
-                    return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
-                } else {
-                    return request.sendJson(data);
-                }
-            } else {
-                return request.send();
-            }
-        });
-    }
-    
-    /**
-     * 发起DELETE请求
-     * @param url 请求URL
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse delete(String url) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.deleteAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            return request.send();
-        });
-    }
-    
-    /**
-     * 发起PATCH请求
-     * @param url 请求URL
-     * @param data 请求数据
-     * @return HTTP响应
-     */
-    @HostAccess.Export
-    public PyHttpResponse patch(String url, Object data) {
-        validateUrlSecurity(url);
-        return executeRequest(() -> {
-            HttpRequest<Buffer> request = client.patchAbs(url);
-            if (!headers.isEmpty()) {
-                request.putHeaders(headers);
-            }
-            
-            if (data != null) {
-                if (data instanceof String) {
-                    return request.sendBuffer(Buffer.buffer((String) data));
-                } else if (data instanceof Map) {
-                    @SuppressWarnings("unchecked")
-                    Map<String, String> mapData = (Map<String, String>) data;
-                    return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
-                } else {
-                    return request.sendJson(data);
-                }
-            } else {
-                return request.send();
-            }
-        });
-    }
-    
-    /**
-     * 设置请求头
-     * @param name 头名称
-     * @param value 头值
-     * @return 当前客户端实例（支持链式调用）
-     */
-    @HostAccess.Export
-    public PyHttpClient put_header(String name, String value) {
-        if (name != null && value != null) {
-            headers.set(name, value);
-        }
-        return this;
-    }
-    
-    /**
-     * 批量设置请求头
-     * @param headersMap 请求头Map
-     * @return 当前客户端实例（支持链式调用）
-     */
-    @HostAccess.Export
-    public PyHttpClient put_headers(Map<String, String> headersMap) {
-        if (headersMap != null) {
-            for (Map.Entry<String, String> entry : headersMap.entrySet()) {
-                if (entry.getKey() != null && entry.getValue() != null) {
-                    headers.set(entry.getKey(), entry.getValue());
-                }
-            }
-        }
-        return this;
-    }
-    
-    /**
-     * 删除指定请求头
-     * @param name 头名称
-     * @return 当前客户端实例（支持链式调用）
-     */
-    @HostAccess.Export
-    public PyHttpClient remove_header(String name) {
-        if (name != null) {
-            headers.remove(name);
-        }
-        return this;
-    }
-    
-    /**
-     * 清空所有请求头（保留默认头）
-     * @return 当前客户端实例（支持链式调用）
-     */
-    @HostAccess.Export
-    public PyHttpClient clear_headers() {
-        headers.clear();
-        initDefaultHeaders();
-        return this;
-    }
-    
-    /**
-     * 获取所有请求头
-     * @return 请求头Map
-     */
-    @HostAccess.Export
-    public Map<String, String> get_headers() {
-        Map<String, String> result = new HashMap<>();
-        for (String name : headers.names()) {
-            result.put(name, headers.get(name));
-        }
-        return result;
-    }
-    
-    /**
-     * 设置请求超时时间
-     * @param seconds 超时时间（秒）
-     * @return 当前客户端实例（支持链式调用）
-     */
-    @HostAccess.Export
-    public PyHttpClient set_timeout(int seconds) {
-        if (seconds > 0) {
-            this.timeoutSeconds = seconds;
-        }
-        return this;
-    }
-    
-    /**
-     * URL编码
-     * @param str 要编码的字符串
-     * @return 编码后的字符串
-     */
-    @HostAccess.Export
-    public static String url_encode(String str) {
-        if (str == null) {
-            return null;
-        }
-        try {
-            return URLEncoder.encode(str, StandardCharsets.UTF_8.name());
-        } catch (Exception e) {
-            log.error("URL编码失败", e);
-            return str;
-        }
-    }
-    
-    /**
-     * URL解码
-     * @param str 要解码的字符串
-     * @return 解码后的字符串
-     */
-    @HostAccess.Export
-    public static String url_decode(String str) {
-        if (str == null) {
-            return null;
-        }
-        try {
-            return URLDecoder.decode(str, StandardCharsets.UTF_8.name());
-        } catch (Exception e) {
-            log.error("URL解码失败", e);
-            return str;
-        }
-    }
-    
-    /**
-     * 执行HTTP请求（同步）
-     */
-    private PyHttpResponse executeRequest(RequestExecutor executor) {
-        try {
-            Promise<HttpResponse<Buffer>> promise = Promise.promise();
-            Future<HttpResponse<Buffer>> future = executor.execute();
-            
-            future.onComplete(result -> {
-                if (result.succeeded()) {
-                    promise.complete(result.result());
-                } else {
-                    promise.fail(result.cause());
-                }
-            }).onFailure(Throwable::printStackTrace);
-            
-            // 等待响应完成（使用配置的超时时间）
-            HttpResponse<Buffer> response = promise.future().toCompletionStage()
-                    .toCompletableFuture()
-                    .get(timeoutSeconds, TimeUnit.SECONDS);
-            
-            return new PyHttpResponse(response);
-            
-        } catch (TimeoutException e) {
-            String errorMsg = "HTTP请求超时（" + timeoutSeconds + "秒）";
-            log.error(errorMsg, e);
-            throw new RuntimeException(errorMsg, e);
-        } catch (Exception e) {
-            String errorMsg = e.getMessage();
-            if (errorMsg == null || errorMsg.trim().isEmpty()) {
-                errorMsg = e.getClass().getSimpleName();
-                if (e.getCause() != null && e.getCause().getMessage() != null) {
-                    errorMsg += ": " + e.getCause().getMessage();
-                }
-            }
-            log.error("HTTP请求执行失败: " + errorMsg, e);
-            throw new RuntimeException("HTTP请求执行失败: " + errorMsg, e);
-        }
-    }
-    
-    /**
-     * 请求执行器接口
-     */
-    @FunctionalInterface
-    private interface RequestExecutor {
-        Future<HttpResponse<Buffer>> execute();
-    }
-    
-    /**
-     * Python HTTP响应封装
-     */
-    public static class PyHttpResponse {
-        
-        private final HttpResponse<Buffer> response;
-        
-        public PyHttpResponse(HttpResponse<Buffer> response) {
-            this.response = response;
-        }
-        
-        /**
-         * 获取响应体（字符串）
-         * @return 响应体字符串
-         */
-        @HostAccess.Export
-        public String text() {
-            return HttpResponseHelper.asText(response);
-        }
-        
-        /**
-         * 获取响应体（字符串）- 别名
-         */
-        @HostAccess.Export
-        public String body() {
-            return text();
-        }
-        
-        /**
-         * 解析JSON响应
-         * @return JSON对象的Map表示
-         */
-        @HostAccess.Export
-        public Object json() {
-            try {
-                JsonObject jsonObject = HttpResponseHelper.asJson(response);
-                if (jsonObject == null || jsonObject.isEmpty()) {
-                    return null;
-                }
-                return jsonObject.getMap();
-            } catch (Exception e) {
-                log.error("解析JSON响应失败", e);
-                throw new RuntimeException("解析JSON响应失败: " + e.getMessage(), e);
-            }
-        }
-        
-        /**
-         * 获取HTTP状态码
-         * @return 状态码
-         */
-        @HostAccess.Export
-        public int status_code() {
-            return response.statusCode();
-        }
-        
-        /**
-         * 获取响应头
-         * @param name 头名称
-         * @return 头值
-         */
-        @HostAccess.Export
-        public String header(String name) {
-            return response.getHeader(name);
-        }
-        
-        /**
-         * 获取所有响应头
-         * @return 响应头Map
-         */
-        @HostAccess.Export
-        public Map<String, String> headers() {
-            MultiMap responseHeaders = response.headers();
-            Map<String, String> result = new HashMap<>();
-            for (String name : responseHeaders.names()) {
-                result.put(name, responseHeaders.get(name));
-            }
-            return result;
-        }
-        
-        /**
-         * 检查请求是否成功
-         * @return true表示成功（2xx状态码）
-         */
-        @HostAccess.Export
-        public boolean ok() {
-            int status = status_code();
-            return status >= 200 && status < 300;
-        }
-        
-        /**
-         * 获取响应体字节数组
-         * @return 响应体字节数组
-         */
-        @HostAccess.Export
-        public byte[] content() {
-            Buffer buffer = response.body();
-            if (buffer == null) {
-                return new byte[0];
-            }
-            return buffer.getBytes();
-        }
-        
-        /**
-         * 获取响应体大小
-         * @return 响应体大小（字节）
-         */
-        @HostAccess.Export
-        public long content_length() {
-            Buffer buffer = response.body();
-            if (buffer == null) {
-                return 0;
-            }
-            return buffer.length();
-        }
-        
-        /**
-         * 获取原始响应对象
-         */
-        public HttpResponse<Buffer> getOriginalResponse() {
-            return response;
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyLogger.java

@@ -1,139 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.HostAccess;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Python日志封装
- * 为Python脚本提供日志功能
- *
- * @author QAIU
- */
-public class PyLogger {
-    
-    private final Logger logger;
-    private final String prefix;
-    
-    public PyLogger(String name) {
-        this.logger = LoggerFactory.getLogger(name);
-        this.prefix = "[" + name + "] ";
-    }
-    
-    public PyLogger(Class<?> clazz) {
-        this.logger = LoggerFactory.getLogger(clazz);
-        this.prefix = "[" + clazz.getSimpleName() + "] ";
-    }
-    
-    /**
-     * 调试日志
-     * @param message 日志消息
-     */
-    @HostAccess.Export
-    public void debug(String message) {
-        logger.debug(prefix + message);
-    }
-    
-    /**
-     * 调试日志（带参数）
-     * @param message 日志消息模板
-     * @param args 参数
-     */
-    @HostAccess.Export
-    public void debug(String message, Object... args) {
-        logger.debug(prefix + message, args);
-    }
-    
-    /**
-     * 信息日志
-     * @param message 日志消息
-     */
-    @HostAccess.Export
-    public void info(String message) {
-        logger.info(prefix + message);
-    }
-    
-    /**
-     * 信息日志（带参数）
-     * @param message 日志消息模板
-     * @param args 参数
-     */
-    @HostAccess.Export
-    public void info(String message, Object... args) {
-        logger.info(prefix + message, args);
-    }
-    
-    /**
-     * 警告日志
-     * @param message 日志消息
-     */
-    @HostAccess.Export
-    public void warn(String message) {
-        logger.warn(prefix + message);
-    }
-    
-    /**
-     * 警告日志（带参数）
-     * @param message 日志消息模板
-     * @param args 参数
-     */
-    @HostAccess.Export
-    public void warn(String message, Object... args) {
-        logger.warn(prefix + message, args);
-    }
-    
-    /**
-     * 错误日志
-     * @param message 日志消息
-     */
-    @HostAccess.Export
-    public void error(String message) {
-        logger.error(prefix + message);
-    }
-    
-    /**
-     * 错误日志（带参数）
-     * @param message 日志消息模板
-     * @param args 参数
-     */
-    @HostAccess.Export
-    public void error(String message, Object... args) {
-        logger.error(prefix + message, args);
-    }
-    
-    /**
-     * 错误日志（带异常）
-     * @param message 日志消息
-     * @param throwable 异常对象
-     */
-    @HostAccess.Export
-    public void error(String message, Throwable throwable) {
-        logger.error(prefix + message, throwable);
-    }
-    
-    /**
-     * 检查是否启用调试级别日志
-     * @return true表示启用，false表示不启用
-     */
-    @HostAccess.Export
-    public boolean isDebugEnabled() {
-        return logger.isDebugEnabled();
-    }
-    
-    /**
-     * 检查是否启用信息级别日志
-     * @return true表示启用，false表示不启用
-     */
-    @HostAccess.Export
-    public boolean isInfoEnabled() {
-        return logger.isInfoEnabled();
-    }
-    
-    /**
-     * 获取原始Logger对象
-     * @return Logger对象
-     */
-    public Logger getOriginalLogger() {
-        return logger;
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyParserExecutor.java

@@ -1,272 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.WebClientVertxInit;
-import cn.qaiu.entity.FileInfo;
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.IPanTool;
-import cn.qaiu.parser.custom.CustomParserConfig;
-import io.vertx.core.Future;
-import io.vertx.core.WorkerExecutor;
-import io.vertx.core.json.JsonObject;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Python解析器执行器
- * 使用GraalPy执行Python解析器脚本
- * 实现IPanTool接口，执行Python解析器逻辑
- * 使用 PyContextPool 进行 Engine 池化管理
- *
- * @author QAIU
- */
-public class PyParserExecutor implements IPanTool {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyParserExecutor.class);
-    
-    private static final WorkerExecutor EXECUTOR = WebClientVertxInit.get()
-            .createSharedWorkerExecutor("py-parser-executor", 32);
-    
-    // Context池实例
-    private static final PyContextPool CONTEXT_POOL = PyContextPool.getInstance();
-    
-    private final CustomParserConfig config;
-    private final ShareLinkInfo shareLinkInfo;
-    private final PyHttpClient httpClient;
-    private final PyLogger pyLogger;
-    private final PyShareLinkInfoWrapper shareLinkInfoWrapper;
-    private final PyCryptoUtils cryptoUtils;
-    
-    public PyParserExecutor(ShareLinkInfo shareLinkInfo, CustomParserConfig config) {
-        this.config = config;
-        this.shareLinkInfo = shareLinkInfo;
-        
-        // 检查是否有代理配置
-        JsonObject proxyConfig = null;
-        if (shareLinkInfo.getOtherParam().containsKey("proxy")) {
-            proxyConfig = (JsonObject) shareLinkInfo.getOtherParam().get("proxy");
-        }
-        
-        this.httpClient = new PyHttpClient(proxyConfig);
-        this.pyLogger = new PyLogger("PyParser-" + config.getType());
-        this.shareLinkInfoWrapper = new PyShareLinkInfoWrapper(shareLinkInfo);
-        this.cryptoUtils = new PyCryptoUtils();
-    }
-    
-    /**
-     * 获取ShareLinkInfo对象
-     * @return ShareLinkInfo对象
-     */
-    @Override
-    public ShareLinkInfo getShareLinkInfo() {
-        return shareLinkInfo;
-    }
-    
-    @Override
-    public Future<String> parse() {
-        pyLogger.info("开始执行Python解析器: {}", config.getType());
-        
-        return EXECUTOR.executeBlocking(() -> {
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                // 注入Java对象到Python环境
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", pyLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包如 requests, zlib 等）
-                context.eval("python", config.getPyCode());
-                
-                // 调用parse函数
-                Value parseFunc = bindings.getMember("parse");
-                if (parseFunc == null || !parseFunc.canExecute()) {
-                    throw new RuntimeException("Python代码中未找到parse函数");
-                }
-                
-                Value result = parseFunc.execute(shareLinkInfoWrapper, httpClient, pyLogger);
-                
-                if (result.isString()) {
-                    String downloadUrl = result.asString();
-                    pyLogger.info("解析成功: {}", downloadUrl);
-                    return downloadUrl;
-                } else {
-                    pyLogger.error("parse方法返回值类型错误，期望String，实际: {}", 
-                            result.getMetaObject().toString());
-                    throw new RuntimeException("parse方法返回值类型错误");
-                }
-            } catch (Exception e) {
-                pyLogger.error("Python解析器执行失败: {}", e.getMessage());
-                throw new RuntimeException("Python解析器执行失败: " + e.getMessage(), e);
-            }
-        });
-    }
-    
-    @Override
-    public Future<List<FileInfo>> parseFileList() {
-        pyLogger.info("开始执行Python文件列表解析: {}", config.getType());
-        
-        return EXECUTOR.executeBlocking(() -> {
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                // 注入Java对象到Python环境
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", pyLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包）
-                context.eval("python", config.getPyCode());
-                
-                // 调用parseFileList函数
-                Value parseFileListFunc = bindings.getMember("parse_file_list");
-                if (parseFileListFunc == null || !parseFileListFunc.canExecute()) {
-                    throw new RuntimeException("Python代码中未找到parse_file_list函数");
-                }
-                
-                Value result = parseFileListFunc.execute(shareLinkInfoWrapper, httpClient, pyLogger);
-                
-                List<FileInfo> fileList = convertToFileInfoList(result);
-                pyLogger.info("文件列表解析成功，共 {} 个文件", fileList.size());
-                return fileList;
-            } catch (Exception e) {
-                pyLogger.error("Python文件列表解析失败: {}", e.getMessage());
-                throw new RuntimeException("Python文件列表解析失败: " + e.getMessage(), e);
-            }
-        });
-    }
-    
-    @Override
-    public Future<String> parseById() {
-        pyLogger.info("开始执行Python按ID解析: {}", config.getType());
-        
-        return EXECUTOR.executeBlocking(() -> {
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                // 注入Java对象到Python环境
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", pyLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包）
-                context.eval("python", config.getPyCode());
-                
-                // 调用parseById函数
-                Value parseByIdFunc = bindings.getMember("parse_by_id");
-                if (parseByIdFunc == null || !parseByIdFunc.canExecute()) {
-                    throw new RuntimeException("Python代码中未找到parse_by_id函数");
-                }
-                
-                Value result = parseByIdFunc.execute(shareLinkInfoWrapper, httpClient, pyLogger);
-                
-                if (result.isString()) {
-                    String downloadUrl = result.asString();
-                    pyLogger.info("按ID解析成功: {}", downloadUrl);
-                    return downloadUrl;
-                } else {
-                    pyLogger.error("parse_by_id方法返回值类型错误，期望String，实际: {}", 
-                            result.getMetaObject().toString());
-                    throw new RuntimeException("parse_by_id方法返回值类型错误");
-                }
-            } catch (Exception e) {
-                pyLogger.error("Python按ID解析失败: {}", e.getMessage());
-                throw new RuntimeException("Python按ID解析失败: " + e.getMessage(), e);
-            }
-        });
-    }
-    
-    /**
-     * 将Python列表转换为FileInfo列表
-     */
-    private List<FileInfo> convertToFileInfoList(Value result) {
-        List<FileInfo> fileList = new ArrayList<>();
-        
-        if (result.hasArrayElements()) {
-            long size = result.getArraySize();
-            for (long i = 0; i < size; i++) {
-                Value item = result.getArrayElement(i);
-                FileInfo fileInfo = convertToFileInfo(item);
-                if (fileInfo != null) {
-                    fileList.add(fileInfo);
-                }
-            }
-        }
-        
-        return fileList;
-    }
-    
-    /**
-     * 将Python字典转换为FileInfo
-     */
-    private FileInfo convertToFileInfo(Value item) {
-        try {
-            FileInfo fileInfo = new FileInfo();
-            
-            if (item.hasMember("file_name") || item.hasMember("fileName")) {
-                Value val = item.hasMember("file_name") ? item.getMember("file_name") : item.getMember("fileName");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileName(val.asString());
-                }
-            }
-            if (item.hasMember("file_id") || item.hasMember("fileId")) {
-                Value val = item.hasMember("file_id") ? item.getMember("file_id") : item.getMember("fileId");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileId(val.asString());
-                }
-            }
-            if (item.hasMember("file_type") || item.hasMember("fileType")) {
-                Value val = item.hasMember("file_type") ? item.getMember("file_type") : item.getMember("fileType");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileType(val.asString());
-                }
-            }
-            if (item.hasMember("size")) {
-                Value val = item.getMember("size");
-                if (val != null && !val.isNull() && val.isNumber()) {
-                    fileInfo.setSize(val.asLong());
-                }
-            }
-            if (item.hasMember("size_str") || item.hasMember("sizeStr")) {
-                Value val = item.hasMember("size_str") ? item.getMember("size_str") : item.getMember("sizeStr");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setSizeStr(val.asString());
-                }
-            }
-            if (item.hasMember("create_time") || item.hasMember("createTime")) {
-                Value val = item.hasMember("create_time") ? item.getMember("create_time") : item.getMember("createTime");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setCreateTime(val.asString());
-                }
-            }
-            if (item.hasMember("pan_type") || item.hasMember("panType")) {
-                Value val = item.hasMember("pan_type") ? item.getMember("pan_type") : item.getMember("panType");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setPanType(val.asString());
-                }
-            }
-            if (item.hasMember("parser_url") || item.hasMember("parserUrl")) {
-                Value val = item.hasMember("parser_url") ? item.getMember("parser_url") : item.getMember("parserUrl");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setParserUrl(val.asString());
-                }
-            }
-            
-            return fileInfo;
-            
-        } catch (Exception e) {
-            pyLogger.error("转换FileInfo对象失败", e);
-            return null;
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyPlaygroundExecutor.java

@@ -1,471 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.FileInfo;
-import cn.qaiu.entity.ShareLinkInfo;
-import io.vertx.core.Future;
-import io.vertx.core.Promise;
-import io.vertx.core.json.JsonObject;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.PolyglotException;
-import org.graalvm.polyglot.Value;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.*;
-
-/**
- * Python演练场执行器
- * 用于临时执行Python代码，不注册到解析器注册表
- * 使用独立线程池避免Vert.x BlockedThreadChecker警告
- * 使用 PyContextPool 进行 Engine 和 Context 池化管理
- *
- * @author QAIU
- */
-public class PyPlaygroundExecutor {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyPlaygroundExecutor.class);
-    
-    // Python执行超时时间（秒）
-    private static final long EXECUTION_TIMEOUT_SECONDS = 30;
-    
-    // Context池实例
-    private static final PyContextPool CONTEXT_POOL = PyContextPool.getInstance();
-    
-    private final ShareLinkInfo shareLinkInfo;
-    private final String pyCode;
-    private final PyHttpClient httpClient;
-    private final PyPlaygroundLogger playgroundLogger;
-    private final PyShareLinkInfoWrapper shareLinkInfoWrapper;
-    private final PyCryptoUtils cryptoUtils;
-    
-    /**
-     * 创建演练场执行器
-     *
-     * @param shareLinkInfo 分享链接信息
-     * @param pyCode Python代码
-     */
-    public PyPlaygroundExecutor(ShareLinkInfo shareLinkInfo, String pyCode) {
-        this.shareLinkInfo = shareLinkInfo;
-        this.pyCode = pyCode;
-        
-        // 检查是否有代理配置
-        JsonObject proxyConfig = null;
-        if (shareLinkInfo.getOtherParam().containsKey("proxy")) {
-            proxyConfig = (JsonObject) shareLinkInfo.getOtherParam().get("proxy");
-        }
-        
-        this.httpClient = new PyHttpClient(proxyConfig);
-        this.playgroundLogger = new PyPlaygroundLogger();
-        this.shareLinkInfoWrapper = new PyShareLinkInfoWrapper(shareLinkInfo);
-        this.cryptoUtils = new PyCryptoUtils();
-    }
-    
-    /**
-     * 执行parse方法（异步，带超时控制）
-     */
-    public Future<String> executeParseAsync() {
-        Promise<String> promise = Promise.promise();
-        
-        // 在执行前进行安全检查
-        PyCodeSecurityChecker.SecurityCheckResult securityResult = PyCodeSecurityChecker.check(pyCode);
-        if (!securityResult.isPassed()) {
-            playgroundLogger.errorJava("安全检查失败: " + securityResult.getMessage());
-            promise.fail(new SecurityException("代码安全检查失败: " + securityResult.getMessage()));
-            return promise.future();
-        }
-        playgroundLogger.debugJava("安全检查通过");
-        
-        // Python代码预处理 - 检测并注入猴子补丁
-        PyCodePreprocessor.PyPreprocessResult preprocessResult = PyCodePreprocessor.preprocess(pyCode);
-        playgroundLogger.infoJava(preprocessResult.getLogMessage());
-        String codeToExecute = preprocessResult.getProcessedCode();
-        
-        CompletableFuture<String> executionFuture = CompletableFuture.supplyAsync(() -> {
-            playgroundLogger.infoJava("开始执行parse方法");
-            
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                // 注入Java对象到Python环境
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", playgroundLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包如 requests, zlib 等）
-                playgroundLogger.debugJava("执行Python代码");
-                context.eval("python", codeToExecute);
-                
-                // 调用parse函数
-                Value parseFunc = bindings.getMember("parse");
-                if (parseFunc == null || !parseFunc.canExecute()) {
-                    playgroundLogger.errorJava("Python代码中未找到parse函数");
-                    throw new RuntimeException("Python代码中未找到parse函数");
-                }
-                
-                playgroundLogger.debugJava("调用parse函数");
-                Value result = parseFunc.execute(shareLinkInfoWrapper, httpClient, playgroundLogger);
-                
-                if (result.isString()) {
-                    String downloadUrl = result.asString();
-                    playgroundLogger.infoJava("解析成功，返回结果: " + downloadUrl);
-                    return downloadUrl;
-                } else {
-                    String errorMsg = "parse方法返回值类型错误，期望String，实际: " + 
-                            (result.isNull() ? "null" : result.getMetaObject().toString());
-                    playgroundLogger.errorJava(errorMsg);
-                    throw new RuntimeException(errorMsg);
-                }
-            } catch (PolyglotException e) {
-                // 处理 Python 语法错误和运行时错误
-                String errorMsg = formatPolyglotException(e);
-                playgroundLogger.errorJava("执行parse方法失败: " + errorMsg);
-                throw new RuntimeException(errorMsg, e);
-            } catch (Exception e) {
-                String errorMsg = e.getMessage();
-                if (errorMsg == null || errorMsg.isEmpty()) {
-                    errorMsg = e.getClass().getName();
-                    if (e.getCause() != null) {
-                        errorMsg += ": " + (e.getCause().getMessage() != null ? 
-                                e.getCause().getMessage() : e.getCause().getClass().getName());
-                    }
-                }
-                playgroundLogger.errorJava("执行parse方法失败: " + errorMsg, e);
-                throw new RuntimeException(errorMsg, e);
-            }
-        }, CONTEXT_POOL.getPythonExecutor());
-        
-        // 创建超时任务
-        ScheduledFuture<?> timeoutTask = CONTEXT_POOL.getTimeoutScheduler().schedule(() -> {
-            if (!executionFuture.isDone()) {
-                executionFuture.cancel(true);
-                playgroundLogger.errorJava("执行超时，已强制中断");
-                log.warn("Python执行超时，已强制取消");
-            }
-        }, EXECUTION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        
-        // 处理执行结果
-        executionFuture.whenComplete((result, error) -> {
-            timeoutTask.cancel(false);
-            
-            if (error != null) {
-                if (error instanceof CancellationException) {
-                    String timeoutMsg = "Python执行超时（超过" + EXECUTION_TIMEOUT_SECONDS + "秒），已强制中断";
-                    playgroundLogger.errorJava(timeoutMsg);
-                    log.error(timeoutMsg);
-                    promise.fail(new RuntimeException(timeoutMsg));
-                } else {
-                    Throwable cause = error.getCause();
-                    promise.fail(cause != null ? cause : error);
-                }
-            } else {
-                promise.complete(result);
-            }
-        });
-        
-        return promise.future();
-    }
-    
-    /**
-     * 执行parseFileList方法（异步，带超时控制）
-     */
-    public Future<List<FileInfo>> executeParseFileListAsync() {
-        Promise<List<FileInfo>> promise = Promise.promise();
-        
-        // Python代码预处理 - 检测并注入猴子补丁
-        PyCodePreprocessor.PyPreprocessResult preprocessResult = PyCodePreprocessor.preprocess(pyCode);
-        playgroundLogger.infoJava(preprocessResult.getLogMessage());
-        String codeToExecute = preprocessResult.getProcessedCode();
-        
-        CompletableFuture<List<FileInfo>> executionFuture = CompletableFuture.supplyAsync(() -> {
-            playgroundLogger.infoJava("开始执行parse_file_list方法");
-            
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", playgroundLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包）
-                context.eval("python", codeToExecute);
-                
-                Value parseFileListFunc = bindings.getMember("parse_file_list");
-                if (parseFileListFunc == null || !parseFileListFunc.canExecute()) {
-                    playgroundLogger.errorJava("Python代码中未找到parse_file_list函数");
-                    throw new RuntimeException("Python代码中未找到parse_file_list函数");
-                }
-                
-                playgroundLogger.debugJava("调用parse_file_list函数");
-                Value result = parseFileListFunc.execute(shareLinkInfoWrapper, httpClient, playgroundLogger);
-                
-                List<FileInfo> fileList = convertToFileInfoList(result);
-                playgroundLogger.infoJava("文件列表解析成功，共 " + fileList.size() + " 个文件");
-                return fileList;
-            } catch (PolyglotException e) {
-                // 处理 Python 语法错误和运行时错误
-                String errorMsg = formatPolyglotException(e);
-                playgroundLogger.errorJava("执行parse_file_list方法失败: " + errorMsg);
-                throw new RuntimeException(errorMsg, e);
-            } catch (Exception e) {
-                playgroundLogger.errorJava("执行parse_file_list方法失败: " + e.getMessage(), e);
-                throw new RuntimeException(e);
-            }
-        }, CONTEXT_POOL.getPythonExecutor());
-        
-        ScheduledFuture<?> timeoutTask = CONTEXT_POOL.getTimeoutScheduler().schedule(() -> {
-            if (!executionFuture.isDone()) {
-                executionFuture.cancel(true);
-                playgroundLogger.errorJava("执行超时，已强制中断");
-            }
-        }, EXECUTION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        
-        executionFuture.whenComplete((result, error) -> {
-            timeoutTask.cancel(false);
-            
-            if (error != null) {
-                if (error instanceof CancellationException) {
-                    String timeoutMsg = "Python执行超时（超过" + EXECUTION_TIMEOUT_SECONDS + "秒），已强制中断";
-                    promise.fail(new RuntimeException(timeoutMsg));
-                } else {
-                    Throwable cause = error.getCause();
-                    promise.fail(cause != null ? cause : error);
-                }
-            } else {
-                promise.complete(result);
-            }
-        });
-        
-        return promise.future();
-    }
-    
-    /**
-     * 执行parseById方法（异步，带超时控制）
-     */
-    public Future<String> executeParseByIdAsync() {
-        Promise<String> promise = Promise.promise();
-        
-        // Python代码预处理 - 检测并注入猴子补丁
-        PyCodePreprocessor.PyPreprocessResult preprocessResult = PyCodePreprocessor.preprocess(pyCode);
-        playgroundLogger.infoJava(preprocessResult.getLogMessage());
-        String codeToExecute = preprocessResult.getProcessedCode();
-        
-        CompletableFuture<String> executionFuture = CompletableFuture.supplyAsync(() -> {
-            playgroundLogger.infoJava("开始执行parse_by_id方法");
-            
-            // 使用池化的 Context，自动归还
-            try (PyContextPool.PooledContext pc = CONTEXT_POOL.acquire()) {
-                Context context = pc.getContext();
-                Value bindings = context.getBindings("python");
-                bindings.putMember("http", httpClient);
-                bindings.putMember("logger", playgroundLogger);
-                bindings.putMember("share_link_info", shareLinkInfoWrapper);
-                bindings.putMember("crypto", cryptoUtils);
-                
-                // 执行Python代码（已支持真正的 pip 包）
-                context.eval("python", codeToExecute);
-                
-                Value parseByIdFunc = bindings.getMember("parse_by_id");
-                if (parseByIdFunc == null || !parseByIdFunc.canExecute()) {
-                    playgroundLogger.errorJava("Python代码中未找到parse_by_id函数");
-                    throw new RuntimeException("Python代码中未找到parse_by_id函数");
-                }
-                
-                playgroundLogger.debugJava("调用parse_by_id函数");
-                Value result = parseByIdFunc.execute(shareLinkInfoWrapper, httpClient, playgroundLogger);
-                
-                if (result.isString()) {
-                    String downloadUrl = result.asString();
-                    playgroundLogger.infoJava("按ID解析成功，返回结果: " + downloadUrl);
-                    return downloadUrl;
-                } else {
-                    String errorMsg = "parse_by_id方法返回值类型错误";
-                    playgroundLogger.errorJava(errorMsg);
-                    throw new RuntimeException(errorMsg);
-                }
-            } catch (Exception e) {
-                playgroundLogger.errorJava("执行parse_by_id方法失败: " + e.getMessage(), e);
-                throw new RuntimeException(e);
-            }
-        }, CONTEXT_POOL.getPythonExecutor());
-        
-        ScheduledFuture<?> timeoutTask = CONTEXT_POOL.getTimeoutScheduler().schedule(() -> {
-            if (!executionFuture.isDone()) {
-                executionFuture.cancel(true);
-                playgroundLogger.errorJava("执行超时，已强制中断");
-            }
-        }, EXECUTION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        
-        executionFuture.whenComplete((result, error) -> {
-            timeoutTask.cancel(false);
-            
-            if (error != null) {
-                if (error instanceof CancellationException) {
-                    String timeoutMsg = "Python执行超时（超过" + EXECUTION_TIMEOUT_SECONDS + "秒），已强制中断";
-                    promise.fail(new RuntimeException(timeoutMsg));
-                } else {
-                    Throwable cause = error.getCause();
-                    promise.fail(cause != null ? cause : error);
-                }
-            } else {
-                promise.complete(result);
-            }
-        });
-        
-        return promise.future();
-    }
-    
-    /**
-     * 获取日志列表
-     */
-    public List<PyPlaygroundLogger.LogEntry> getLogs() {
-        return playgroundLogger.getLogs();
-    }
-    
-    /**
-     * 将Python列表转换为FileInfo列表
-     */
-    private List<FileInfo> convertToFileInfoList(Value result) {
-        List<FileInfo> fileList = new ArrayList<>();
-        
-        if (result.hasArrayElements()) {
-            long size = result.getArraySize();
-            for (long i = 0; i < size; i++) {
-                Value item = result.getArrayElement(i);
-                FileInfo fileInfo = convertToFileInfo(item);
-                if (fileInfo != null) {
-                    fileList.add(fileInfo);
-                }
-            }
-        }
-        
-        return fileList;
-    }
-    
-    /**
-     * 将Python字典转换为FileInfo
-     */
-    private FileInfo convertToFileInfo(Value item) {
-        try {
-            FileInfo fileInfo = new FileInfo();
-            
-            if (item.hasMember("file_name") || item.hasMember("fileName")) {
-                Value val = item.hasMember("file_name") ? item.getMember("file_name") : item.getMember("fileName");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileName(val.asString());
-                }
-            }
-            if (item.hasMember("file_id") || item.hasMember("fileId")) {
-                Value val = item.hasMember("file_id") ? item.getMember("file_id") : item.getMember("fileId");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileId(val.asString());
-                }
-            }
-            if (item.hasMember("file_type") || item.hasMember("fileType")) {
-                Value val = item.hasMember("file_type") ? item.getMember("file_type") : item.getMember("fileType");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setFileType(val.asString());
-                }
-            }
-            if (item.hasMember("size")) {
-                Value val = item.getMember("size");
-                if (val != null && !val.isNull() && val.isNumber()) {
-                    fileInfo.setSize(val.asLong());
-                }
-            }
-            if (item.hasMember("pan_type") || item.hasMember("panType")) {
-                Value val = item.hasMember("pan_type") ? item.getMember("pan_type") : item.getMember("panType");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setPanType(val.asString());
-                }
-            }
-            if (item.hasMember("parser_url") || item.hasMember("parserUrl")) {
-                Value val = item.hasMember("parser_url") ? item.getMember("parser_url") : item.getMember("parserUrl");
-                if (val != null && !val.isNull()) {
-                    fileInfo.setParserUrl(val.asString());
-                }
-            }
-            
-            return fileInfo;
-            
-        } catch (Exception e) {
-            playgroundLogger.errorJava("转换FileInfo对象失败: " + e.getMessage());
-            return null;
-        }
-    }
-    
-    /**
-     * 格式化 PolyglotException 异常信息，提取详细的错误位置和描述
-     */
-    private String formatPolyglotException(PolyglotException e) {
-        StringBuilder sb = new StringBuilder();
-        
-        // 判断是否为语法错误
-        if (e.isSyntaxError()) {
-            sb.append("Python语法错误: ");
-        } else if (e.isGuestException()) {
-            sb.append("Python运行时错误: ");
-        } else {
-            sb.append("Python执行错误: ");
-        }
-        
-        // 添加错误消息
-        String message = e.getMessage();
-        if (message != null && !message.isEmpty()) {
-            sb.append(message);
-        }
-        
-        // 添加源代码位置信息
-        if (e.getSourceLocation() != null) {
-            org.graalvm.polyglot.SourceSection sourceSection = e.getSourceLocation();
-            sb.append("\n位置: ");
-            
-            // 文件名（如果有）
-            if (sourceSection.getSource() != null && sourceSection.getSource().getName() != null) {
-                sb.append(sourceSection.getSource().getName()).append(", ");
-            }
-            
-            // 行号和列号
-            sb.append("第 ").append(sourceSection.getStartLine()).append(" 行");
-            if (sourceSection.hasColumns()) {
-                sb.append(", 第 ").append(sourceSection.getStartColumn()).append(" 列");
-            }
-            
-            // 显示出错的代码行（如果可用）
-            if (sourceSection.hasCharIndex() && sourceSection.getCharacters() != null) {
-                sb.append("\n错误代码: ").append(sourceSection.getCharacters().toString().trim());
-            }
-        }
-        
-        // 添加堆栈跟踪（仅显示Python部分）
-        if (e.isGuestException() && e.getPolyglotStackTrace() != null) {
-            sb.append("\n\nPython堆栈跟踪:");
-            boolean foundPythonFrame = false;
-            for (PolyglotException.StackFrame frame : e.getPolyglotStackTrace()) {
-                if (frame.isGuestFrame() && frame.getLanguage() != null && 
-                    frame.getLanguage().getId().equals("python")) {
-                    foundPythonFrame = true;
-                    sb.append("\n  at ").append(frame.getRootName() != null ? frame.getRootName() : "<unknown>");
-                    if (frame.getSourceLocation() != null) {
-                        org.graalvm.polyglot.SourceSection loc = frame.getSourceLocation();
-                        sb.append(" (");
-                        if (loc.getSource() != null && loc.getSource().getName() != null) {
-                            sb.append(loc.getSource().getName()).append(":");
-                        }
-                        sb.append("line ").append(loc.getStartLine()).append(")");
-                    }
-                }
-            }
-            if (!foundPythonFrame) {
-                sb.append("\n  (无Python堆栈信息)");
-            }
-        }
-        
-        return sb.toString();
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyPlaygroundLogger.java

@@ -1,193 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.HostAccess;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Python演练场日志封装
- * 收集日志信息用于前端显示
- *
- * @author QAIU
- */
-public class PyPlaygroundLogger extends PyLogger {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyPlaygroundLogger.class);
-    
-    private final List<LogEntry> logs = new ArrayList<>();
-    
-    public PyPlaygroundLogger() {
-        super("PyPlayground");
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void debug(String message) {
-        super.debug(message);
-        addLog("DEBUG", message);
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void debug(String message, Object... args) {
-        super.debug(message, args);
-        addLog("DEBUG", formatMessage(message, args));
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void info(String message) {
-        super.info(message);
-        addLog("INFO", message);
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void info(String message, Object... args) {
-        super.info(message, args);
-        addLog("INFO", formatMessage(message, args));
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void warn(String message) {
-        super.warn(message);
-        addLog("WARN", message);
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void warn(String message, Object... args) {
-        super.warn(message, args);
-        addLog("WARN", formatMessage(message, args));
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void error(String message) {
-        super.error(message);
-        addLog("ERROR", message);
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void error(String message, Object... args) {
-        super.error(message, args);
-        addLog("ERROR", formatMessage(message, args));
-    }
-    
-    @Override
-    @HostAccess.Export
-    public void error(String message, Throwable throwable) {
-        super.error(message, throwable);
-        addLog("ERROR", message + " - " + throwable.getMessage());
-    }
-    
-    /**
-     * 添加Java内部日志（不在Python脚本中调用）
-     */
-    public void infoJava(String message) {
-        log.info("[PyPlayground] " + message);
-        addLog("INFO", "[Java] " + message, "java");
-    }
-    
-    public void debugJava(String message) {
-        log.debug("[PyPlayground] " + message);
-        addLog("DEBUG", "[Java] " + message, "java");
-    }
-    
-    public void errorJava(String message) {
-        log.error("[PyPlayground] " + message);
-        addLog("ERROR", "[Java] " + message, "java");
-    }
-    
-    public void errorJava(String message, Throwable throwable) {
-        log.error("[PyPlayground] " + message, throwable);
-        addLog("ERROR", "[Java] " + message + " - " + throwable.getMessage(), "java");
-    }
-    
-    private void addLog(String level, String message) {
-        addLog(level, message, "python");
-    }
-    
-    private void addLog(String level, String message, String source) {
-        logs.add(new LogEntry(level, message, System.currentTimeMillis(), source));
-    }
-    
-    private String formatMessage(String message, Object... args) {
-        if (args == null || args.length == 0) {
-            return message;
-        }
-        
-        // 简单的占位符替换
-        String result = message;
-        for (Object arg : args) {
-            int index = result.indexOf("{}");
-            if (index >= 0) {
-                result = result.substring(0, index) + (arg != null ? arg.toString() : "null") + result.substring(index + 2);
-            }
-        }
-        return result;
-    }
-    
-    /**
-     * 获取所有日志
-     */
-    public List<LogEntry> getLogs() {
-        return new ArrayList<>(logs);
-    }
-    
-    /**
-     * 清空日志
-     */
-    public void clearLogs() {
-        logs.clear();
-    }
-    
-    /**
-     * 获取日志数量
-     */
-    public int size() {
-        return logs.size();
-    }
-    
-    /**
-     * 日志条目
-     */
-    public static class LogEntry {
-        private final String level;
-        private final String message;
-        private final long timestamp;
-        private final String source;
-        
-        public LogEntry(String level, String message, long timestamp) {
-            this(level, message, timestamp, "python");
-        }
-        
-        public LogEntry(String level, String message, long timestamp, String source) {
-            this.level = level;
-            this.message = message;
-            this.timestamp = timestamp;
-            this.source = source;
-        }
-        
-        public String getLevel() {
-            return level;
-        }
-        
-        public String getMessage() {
-            return message;
-        }
-        
-        public long getTimestamp() {
-            return timestamp;
-        }
-        
-        public String getSource() {
-            return source;
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyScriptLoader.java

@@ -1,334 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import cn.qaiu.parser.custom.CustomParserConfig;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.stream.Stream;
-
-/**
- * Python脚本加载器
- * 自动加载资源目录和外部目录的Python脚本文件
- *
- * @author QAIU
- */
-public class PyScriptLoader {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyScriptLoader.class);
-    
-    private static final String RESOURCE_PATH = "custom-parsers/py";
-    private static final String EXTERNAL_PATH = "./custom-parsers/py";
-    
-    // 系统属性配置的外部目录路径
-    private static final String EXTERNAL_PATH_PROPERTY = "parser.custom-parsers.py.path";
-    
-    /**
-     * 加载所有Python脚本
-     * @return 解析器配置列表
-     */
-    public static List<CustomParserConfig> loadAllScripts() {
-        List<CustomParserConfig> configs = new ArrayList<>();
-        
-        // 1. 加载资源目录下的Python文件
-        try {
-            List<CustomParserConfig> resourceConfigs = loadFromResources();
-            configs.addAll(resourceConfigs);
-            log.info("从资源目录加载了 {} 个Python解析器", resourceConfigs.size());
-        } catch (Exception e) {
-            log.warn("从资源目录加载Python脚本失败", e);
-        }
-        
-        // 2. 加载外部目录下的Python文件
-        try {
-            List<CustomParserConfig> externalConfigs = loadFromExternal();
-            configs.addAll(externalConfigs);
-            log.info("从外部目录加载了 {} 个Python解析器", externalConfigs.size());
-        } catch (Exception e) {
-            log.warn("从外部目录加载Python脚本失败", e);
-        }
-        
-        log.info("总共加载了 {} 个Python解析器", configs.size());
-        return configs;
-    }
-    
-    /**
-     * 从资源目录加载Python脚本
-     */
-    private static List<CustomParserConfig> loadFromResources() {
-        List<CustomParserConfig> configs = new ArrayList<>();
-        
-        try {
-            List<String> resourceFiles = getResourceFileList();
-            resourceFiles.sort(String::compareTo);
-            
-            for (String resourceFile : resourceFiles) {
-                try {
-                    InputStream inputStream = PyScriptLoader.class.getClassLoader()
-                            .getResourceAsStream(resourceFile);
-                    
-                    if (inputStream != null) {
-                        String pyCode = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
-                        CustomParserConfig config = PyScriptMetadataParser.parseScript(pyCode);
-                        configs.add(config);
-                        
-                        String fileName = resourceFile.substring(resourceFile.lastIndexOf('/') + 1);
-                        log.debug("从资源目录加载Python脚本: {}", fileName);
-                    }
-                } catch (Exception e) {
-                    log.warn("加载资源脚本失败: {}", resourceFile, e);
-                }
-            }
-            
-        } catch (Exception e) {
-            log.error("从资源目录加载脚本时发生异常", e);
-        }
-        
-        return configs;
-    }
-    
-    /**
-     * 获取资源目录中的Python文件列表
-     */
-    private static List<String> getResourceFileList() {
-        List<String> resourceFiles = new ArrayList<>();
-        
-        try {
-            java.net.URL resourceUrl = PyScriptLoader.class.getClassLoader()
-                    .getResource(RESOURCE_PATH);
-            
-            if (resourceUrl != null) {
-                String protocol = resourceUrl.getProtocol();
-                
-                if ("jar".equals(protocol)) {
-                    resourceFiles = getJarResourceFiles(resourceUrl);
-                } else if ("file".equals(protocol)) {
-                    resourceFiles = getFileSystemResourceFiles(resourceUrl);
-                }
-            }
-        } catch (Exception e) {
-            log.debug("获取资源文件列表失败", e);
-        }
-        
-        return resourceFiles;
-    }
-    
-    /**
-     * 获取JAR包内的Python资源文件列表
-     */
-    private static List<String> getJarResourceFiles(java.net.URL jarUrl) {
-        List<String> resourceFiles = new ArrayList<>();
-        
-        try {
-            String jarPath = jarUrl.getPath().substring(5, jarUrl.getPath().indexOf("!"));
-            JarFile jarFile = new JarFile(jarPath);
-            
-            Enumeration<JarEntry> entries = jarFile.entries();
-            while (entries.hasMoreElements()) {
-                JarEntry entry = entries.nextElement();
-                String entryName = entry.getName();
-                
-                if (entryName.startsWith(RESOURCE_PATH + "/") && 
-                    entryName.endsWith(".py") && 
-                    !isExcludedFile(entryName.substring(entryName.lastIndexOf('/') + 1))) {
-                    resourceFiles.add(entryName);
-                }
-            }
-            
-            jarFile.close();
-        } catch (Exception e) {
-            log.debug("解析JAR包资源文件失败", e);
-        }
-        
-        return resourceFiles;
-    }
-    
-    /**
-     * 获取文件系统中的Python资源文件列表
-     */
-    private static List<String> getFileSystemResourceFiles(java.net.URL fileUrl) {
-        List<String> resourceFiles = new ArrayList<>();
-        
-        try {
-            java.io.File resourceDir = new java.io.File(fileUrl.getPath());
-            if (resourceDir.exists() && resourceDir.isDirectory()) {
-                java.io.File[] files = resourceDir.listFiles();
-                if (files != null) {
-                    for (java.io.File file : files) {
-                        if (file.isFile() && file.getName().endsWith(".py") && 
-                            !isExcludedFile(file.getName())) {
-                            resourceFiles.add(RESOURCE_PATH + "/" + file.getName());
-                        }
-                    }
-                }
-            }
-        } catch (Exception e) {
-            log.debug("解析文件系统资源文件失败", e);
-        }
-        
-        return resourceFiles;
-    }
-    
-    /**
-     * 从外部目录加载Python脚本
-     */
-    private static List<CustomParserConfig> loadFromExternal() {
-        List<CustomParserConfig> configs = new ArrayList<>();
-        
-        try {
-            String externalPath = getExternalPath();
-            Path externalDir = Paths.get(externalPath);
-            
-            if (!Files.exists(externalDir) || !Files.isDirectory(externalDir)) {
-                log.debug("外部目录 {} 不存在或不是目录", externalPath);
-                return configs;
-            }
-            
-            try (Stream<Path> paths = Files.walk(externalDir)) {
-                paths.filter(Files::isRegularFile)
-                        .filter(path -> path.toString().endsWith(".py"))
-                        .filter(path -> !isExcludedFile(path.getFileName().toString()))
-                        .forEach(path -> {
-                            try {
-                                String pyCode = Files.readString(path, StandardCharsets.UTF_8);
-                                CustomParserConfig config = PyScriptMetadataParser.parseScript(pyCode);
-                                configs.add(config);
-                                log.debug("从外部目录加载Python脚本: {}", path.getFileName());
-                            } catch (Exception e) {
-                                log.warn("加载外部脚本失败: {}", path.getFileName(), e);
-                            }
-                        });
-            }
-            
-        } catch (Exception e) {
-            log.error("从外部目录加载脚本时发生异常", e);
-        }
-        
-        return configs;
-    }
-    
-    /**
-     * 获取外部目录路径
-     */
-    private static String getExternalPath() {
-        // 1. 检查系统属性
-        String systemProperty = System.getProperty(EXTERNAL_PATH_PROPERTY);
-        if (systemProperty != null && !systemProperty.trim().isEmpty()) {
-            log.debug("使用系统属性配置的Python外部目录: {}", systemProperty);
-            return systemProperty;
-        }
-        
-        // 2. 检查环境变量
-        String envVariable = System.getenv("PARSER_CUSTOM_PARSERS_PY_PATH");
-        if (envVariable != null && !envVariable.trim().isEmpty()) {
-            log.debug("使用环境变量配置的Python外部目录: {}", envVariable);
-            return envVariable;
-        }
-        
-        // 3. 使用默认路径
-        log.debug("使用默认Python外部目录: {}", EXTERNAL_PATH);
-        return EXTERNAL_PATH;
-    }
-    
-    /**
-     * 从指定文件加载Python脚本
-     * @param filePath 文件路径
-     * @return 解析器配置
-     */
-    public static CustomParserConfig loadFromFile(String filePath) {
-        try {
-            Path path = Paths.get(filePath);
-            if (!Files.exists(path)) {
-                throw new IllegalArgumentException("文件不存在: " + filePath);
-            }
-            
-            String pyCode = Files.readString(path, StandardCharsets.UTF_8);
-            return PyScriptMetadataParser.parseScript(pyCode);
-            
-        } catch (IOException e) {
-            throw new RuntimeException("读取文件失败: " + filePath, e);
-        }
-    }
-    
-    /**
-     * 从指定资源路径加载Python脚本
-     * @param resourcePath 资源路径
-     * @return 解析器配置
-     */
-    public static CustomParserConfig loadFromResource(String resourcePath) {
-        try {
-            InputStream inputStream = PyScriptLoader.class.getClassLoader()
-                    .getResourceAsStream(resourcePath);
-            
-            if (inputStream == null) {
-                throw new IllegalArgumentException("资源文件不存在: " + resourcePath);
-            }
-            
-            String pyCode = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
-            return PyScriptMetadataParser.parseScript(pyCode);
-            
-        } catch (IOException e) {
-            throw new RuntimeException("读取资源文件失败: " + resourcePath, e);
-        }
-    }
-    
-    /**
-     * 检查外部目录是否存在
-     */
-    public static boolean isExternalDirectoryExists() {
-        Path externalDir = Paths.get(EXTERNAL_PATH);
-        return Files.exists(externalDir) && Files.isDirectory(externalDir);
-    }
-    
-    /**
-     * 创建外部目录
-     */
-    public static boolean createExternalDirectory() {
-        try {
-            Path externalDir = Paths.get(EXTERNAL_PATH);
-            Files.createDirectories(externalDir);
-            log.info("创建Python外部目录成功: {}", EXTERNAL_PATH);
-            return true;
-        } catch (IOException e) {
-            log.error("创建Python外部目录失败: {}", EXTERNAL_PATH, e);
-            return false;
-        }
-    }
-    
-    /**
-     * 获取外部目录路径
-     */
-    public static String getExternalDirectoryPath() {
-        return EXTERNAL_PATH;
-    }
-    
-    /**
-     * 获取资源目录路径
-     */
-    public static String getResourceDirectoryPath() {
-        return RESOURCE_PATH;
-    }
-    
-    /**
-     * 检查文件是否应该被排除
-     */
-    private static boolean isExcludedFile(String fileName) {
-        return fileName.equals("types.pyi") || 
-               fileName.equals("__init__.py") ||
-               fileName.equals("README.md") ||
-               fileName.contains("_test.") ||
-               fileName.contains("_spec.") ||
-               fileName.startsWith("test_");
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyScriptMetadataParser.java

@@ -1,188 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import cn.qaiu.parser.custom.CustomParserConfig;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Python脚本元数据解析器
- * 解析类油猴格式的元数据注释（Python风格）
- *
- * @author QAIU
- */
-public class PyScriptMetadataParser {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyScriptMetadataParser.class);
-    
-    // 元数据块匹配正则（Python注释风格）
-    // 支持 # ==UserScript== 格式
-    private static final Pattern METADATA_BLOCK_PATTERN = Pattern.compile(
-        "#\\s*==UserScript==\\s*(.*?)\\s*#\\s*==/UserScript==", 
-        Pattern.DOTALL
-    );
-    
-    // 元数据行匹配正则
-    private static final Pattern METADATA_LINE_PATTERN = Pattern.compile(
-        "#\\s*@(\\w+)\\s+(.*)"
-    );
-    
-    /**
-     * 解析Python脚本，提取元数据并构建CustomParserConfig
-     *
-     * @param pyCode Python代码
-     * @return CustomParserConfig配置对象
-     * @throws IllegalArgumentException 如果解析失败或缺少必填字段
-     */
-    public static CustomParserConfig parseScript(String pyCode) {
-        if (StringUtils.isBlank(pyCode)) {
-            throw new IllegalArgumentException("Python代码不能为空");
-        }
-        
-        // 1. 提取元数据块
-        Map<String, String> metadata = extractMetadata(pyCode);
-        
-        // 2. 验证必填字段
-        validateRequiredFields(metadata);
-        
-        // 3. 构建CustomParserConfig
-        return buildConfig(metadata, pyCode);
-    }
-    
-    /**
-     * 提取元数据
-     */
-    private static Map<String, String> extractMetadata(String pyCode) {
-        Map<String, String> metadata = new HashMap<>();
-        
-        Matcher blockMatcher = METADATA_BLOCK_PATTERN.matcher(pyCode);
-        if (!blockMatcher.find()) {
-            throw new IllegalArgumentException("未找到元数据块，请确保包含 # ==UserScript== ... # ==/UserScript== 格式的注释");
-        }
-        
-        String metadataBlock = blockMatcher.group(1);
-        Matcher lineMatcher = METADATA_LINE_PATTERN.matcher(metadataBlock);
-        
-        while (lineMatcher.find()) {
-            String key = lineMatcher.group(1).toLowerCase();
-            String value = lineMatcher.group(2).trim();
-            metadata.put(key, value);
-        }
-        
-        log.debug("解析到Python脚本元数据: {}", metadata);
-        return metadata;
-    }
-    
-    /**
-     * 验证必填字段
-     */
-    private static void validateRequiredFields(Map<String, String> metadata) {
-        if (!metadata.containsKey("name")) {
-            throw new IllegalArgumentException("缺少必填字段 @name");
-        }
-        if (!metadata.containsKey("type")) {
-            throw new IllegalArgumentException("缺少必填字段 @type");
-        }
-        if (!metadata.containsKey("displayname")) {
-            throw new IllegalArgumentException("缺少必填字段 @displayName");
-        }
-        if (!metadata.containsKey("match")) {
-            throw new IllegalArgumentException("缺少必填字段 @match");
-        }
-        
-        // 验证match字段包含KEY命名捕获组
-        String matchPattern = metadata.get("match");
-        if (!matchPattern.contains("(?P<KEY>") && !matchPattern.contains("(?<KEY>")) {
-            throw new IllegalArgumentException("@match 正则表达式必须包含命名捕获组 KEY（Python格式: (?P<KEY>...) 或 Java格式: (?<KEY>...)）");
-        }
-    }
-    
-    /**
-     * 构建CustomParserConfig
-     */
-    private static CustomParserConfig buildConfig(Map<String, String> metadata, String pyCode) {
-        CustomParserConfig.Builder builder = CustomParserConfig.builder()
-                .type(metadata.get("type"))
-                .displayName(metadata.get("displayname"))
-                .isPyParser(true)
-                .pyCode(pyCode)
-                .language("python")
-                .metadata(metadata);
-        
-        // 设置匹配正则（将Python风格的(?P<KEY>...)转换为Java风格的(?<KEY>...)）
-        String matchPattern = metadata.get("match");
-        if (StringUtils.isNotBlank(matchPattern)) {
-            // 将Python命名捕获组转换为Java格式
-            matchPattern = matchPattern.replace("(?P<", "(?<");
-            builder.matchPattern(matchPattern);
-        }
-        
-        return builder.build();
-    }
-    
-    /**
-     * 检查Python代码是否包含有效的元数据块
-     *
-     * @param pyCode Python代码
-     * @return true表示包含有效元数据，false表示不包含
-     */
-    public static boolean hasValidMetadata(String pyCode) {
-        if (StringUtils.isBlank(pyCode)) {
-            return false;
-        }
-        
-        try {
-            Map<String, String> metadata = extractMetadata(pyCode);
-            return metadata.containsKey("name") && 
-                   metadata.containsKey("type") && 
-                   metadata.containsKey("displayname") && 
-                   metadata.containsKey("match");
-        } catch (Exception e) {
-            return false;
-        }
-    }
-    
-    /**
-     * 获取脚本类型（不验证必填字段）
-     *
-     * @param pyCode Python代码
-     * @return 脚本类型，如果无法提取则返回null
-     */
-    public static String getScriptType(String pyCode) {
-        if (StringUtils.isBlank(pyCode)) {
-            return null;
-        }
-        
-        try {
-            Map<String, String> metadata = extractMetadata(pyCode);
-            return metadata.get("type");
-        } catch (Exception e) {
-            return null;
-        }
-    }
-    
-    /**
-     * 获取脚本显示名称（不验证必填字段）
-     *
-     * @param pyCode Python代码
-     * @return 显示名称，如果无法提取则返回null
-     */
-    public static String getScriptDisplayName(String pyCode) {
-        if (StringUtils.isBlank(pyCode)) {
-            return null;
-        }
-        
-        try {
-            Map<String, String> metadata = extractMetadata(pyCode);
-            return metadata.get("displayname");
-        } catch (Exception e) {
-            return null;
-        }
-    }
-}

parser/src/main/java/cn/qaiu/parser/custompy/PyShareLinkInfoWrapper.java

@@ -1,262 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import org.graalvm.polyglot.HostAccess;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Map;
-
-/**
- * ShareLinkInfo的Python包装器
- * 为Python脚本提供ShareLinkInfo对象的访问接口
- *
- * @author QAIU
- */
-public class PyShareLinkInfoWrapper {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyShareLinkInfoWrapper.class);
-    
-    private final ShareLinkInfo shareLinkInfo;
-    
-    public PyShareLinkInfoWrapper(ShareLinkInfo shareLinkInfo) {
-        this.shareLinkInfo = shareLinkInfo;
-    }
-    
-    /**
-     * 获取分享URL
-     * @return 分享URL
-     */
-    @HostAccess.Export
-    public String getShareUrl() {
-        return shareLinkInfo.getShareUrl();
-    }
-    
-    /**
-     * Python风格方法名 - 获取分享URL
-     */
-    @HostAccess.Export
-    public String get_share_url() {
-        return getShareUrl();
-    }
-    
-    /**
-     * 获取分享Key
-     * @return 分享Key
-     */
-    @HostAccess.Export
-    public String getShareKey() {
-        return shareLinkInfo.getShareKey();
-    }
-    
-    /**
-     * Python风格方法名 - 获取分享Key
-     */
-    @HostAccess.Export
-    public String get_share_key() {
-        return getShareKey();
-    }
-    
-    /**
-     * 获取分享密码
-     * @return 分享密码
-     */
-    @HostAccess.Export
-    public String getSharePassword() {
-        return shareLinkInfo.getSharePassword();
-    }
-    
-    /**
-     * Python风格方法名 - 获取分享密码
-     */
-    @HostAccess.Export
-    public String get_share_password() {
-        return getSharePassword();
-    }
-    
-    /**
-     * 获取网盘类型
-     * @return 网盘类型
-     */
-    @HostAccess.Export
-    public String getType() {
-        return shareLinkInfo.getType();
-    }
-    
-    /**
-     * Python风格方法名 - 获取网盘类型
-     */
-    @HostAccess.Export
-    public String get_type() {
-        return getType();
-    }
-    
-    /**
-     * 获取网盘名称
-     * @return 网盘名称
-     */
-    @HostAccess.Export
-    public String getPanName() {
-        return shareLinkInfo.getPanName();
-    }
-    
-    /**
-     * Python风格方法名 - 获取网盘名称
-     */
-    @HostAccess.Export
-    public String get_pan_name() {
-        return getPanName();
-    }
-    
-    /**
-     * 获取其他参数
-     * @param key 参数键
-     * @return 参数值
-     */
-    @HostAccess.Export
-    public Object getOtherParam(String key) {
-        if (key == null) {
-            return null;
-        }
-        return shareLinkInfo.getOtherParam().get(key);
-    }
-    
-    /**
-     * Python风格方法名 - 获取其他参数
-     */
-    @HostAccess.Export
-    public Object get_other_param(String key) {
-        return getOtherParam(key);
-    }
-    
-    /**
-     * 获取所有其他参数
-     * @return 参数Map
-     */
-    @HostAccess.Export
-    public Map<String, Object> getAllOtherParams() {
-        return shareLinkInfo.getOtherParam();
-    }
-    
-    /**
-     * Python风格方法名 - 获取所有其他参数
-     */
-    @HostAccess.Export
-    public Map<String, Object> get_all_other_params() {
-        return getAllOtherParams();
-    }
-    
-    /**
-     * 检查是否包含指定参数
-     * @param key 参数键
-     * @return true表示包含，false表示不包含
-     */
-    @HostAccess.Export
-    public boolean hasOtherParam(String key) {
-        if (key == null) {
-            return false;
-        }
-        return shareLinkInfo.getOtherParam().containsKey(key);
-    }
-    
-    /**
-     * Python风格方法名 - 检查是否包含指定参数
-     */
-    @HostAccess.Export
-    public boolean has_other_param(String key) {
-        return hasOtherParam(key);
-    }
-    
-    /**
-     * 获取其他参数的字符串值
-     * @param key 参数键
-     * @return 参数值（字符串形式）
-     */
-    @HostAccess.Export
-    public String getOtherParamAsString(String key) {
-        Object value = getOtherParam(key);
-        return value != null ? value.toString() : null;
-    }
-    
-    /**
-     * Python风格方法名 - 获取其他参数的字符串值
-     */
-    @HostAccess.Export
-    public String get_other_param_as_string(String key) {
-        return getOtherParamAsString(key);
-    }
-    
-    /**
-     * 获取其他参数的整数值
-     * @param key 参数键
-     * @return 参数值（整数形式）
-     */
-    @HostAccess.Export
-    public Integer getOtherParamAsInteger(String key) {
-        Object value = getOtherParam(key);
-        if (value instanceof Integer) {
-            return (Integer) value;
-        } else if (value instanceof Number) {
-            return ((Number) value).intValue();
-        } else if (value instanceof String) {
-            try {
-                return Integer.parseInt((String) value);
-            } catch (NumberFormatException e) {
-                log.warn("无法将参数 {} 转换为整数: {}", key, value);
-                return null;
-            }
-        }
-        return null;
-    }
-    
-    /**
-     * Python风格方法名 - 获取其他参数的整数值
-     */
-    @HostAccess.Export
-    public Integer get_other_param_as_integer(String key) {
-        return getOtherParamAsInteger(key);
-    }
-    
-    /**
-     * 获取其他参数的布尔值
-     * @param key 参数键
-     * @return 参数值（布尔形式）
-     */
-    @HostAccess.Export
-    public Boolean getOtherParamAsBoolean(String key) {
-        Object value = getOtherParam(key);
-        if (value instanceof Boolean) {
-            return (Boolean) value;
-        } else if (value instanceof String) {
-            return Boolean.parseBoolean((String) value);
-        }
-        return null;
-    }
-    
-    /**
-     * Python风格方法名 - 获取其他参数的布尔值
-     */
-    @HostAccess.Export
-    public Boolean get_other_param_as_boolean(String key) {
-        return getOtherParamAsBoolean(key);
-    }
-    
-    /**
-     * 获取原始的ShareLinkInfo对象
-     * @return ShareLinkInfo对象
-     */
-    public ShareLinkInfo getOriginalShareLinkInfo() {
-        return shareLinkInfo;
-    }
-    
-    @Override
-    public String toString() {
-        return "PyShareLinkInfoWrapper{" +
-                "shareUrl='" + getShareUrl() + '\'' +
-                ", shareKey='" + getShareKey() + '\'' +
-                ", sharePassword='" + getSharePassword() + '\'' +
-                ", type='" + getType() + '\'' +
-                ", panName='" + getPanName() + '\'' +
-                '}';
-    }
-}

parser/src/main/java/cn/qaiu/parser/impl/FjTool.java

@@ -3,9 +3,7 @@ package cn.qaiu.parser.impl;
 import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.PanBase;
-import cn.qaiu.util.AESUtils;
-import cn.qaiu.util.FileSizeConverter;
-import cn.qaiu.util.UUIDUtil;
+import cn.qaiu.util.*;
 import io.vertx.core.Future;
 import io.vertx.core.MultiMap;
 import io.vertx.core.Promise;
@@ -13,12 +11,14 @@ import io.vertx.core.buffer.Buffer;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
 import io.vertx.ext.web.client.HttpRequest;
+import io.vertx.ext.web.client.HttpResponse;
 import io.vertx.uritemplate.UriTemplate;
 import org.apache.commons.lang3.StringUtils;
 
 import java.util.ArrayList;
 import java.util.Base64;
 import java.util.List;
+import java.util.UUID;
 
 /**
  * 小飞机网盘
@@ -26,69 +26,113 @@ import java.util.List;
  * @version V016_230609
  */
 public class FjTool extends PanBase {
-    public static final String REFERER_URL = "https://share.feijipan.com/";
-    private static final String API_URL_PREFIX = "https://api.feejii.com/ws/";
+
+    public static final String API_URL0 = "https://api.feijipan.com";
+    private static final String API_URL_PREFIX = "https://api.feijipan.com/ws/";
 
     private static final String FIRST_REQUEST_URL = API_URL_PREFIX + "recommend/list?devType=6&devModel=Chrome" +
             "&uuid={uuid}&extra=2&timestamp={ts}&shareId={shareId}&type=0&offset=1&limit=60";
-    /// recommend/list?devType=6&devModel=Chrome&uuid={uuid}&extra=2&timestamp={ts}&shareId={shareId}&type=0&offset=1&limit=60
-    //  recommend/list?devType=6&devModel=Chrome&uuid={uuid}&extra=2&timestamp={ts}&shareId=JoUTkZYj&type=0&offset=1&limit=60
 
+    private static final String LOGIN_URL = API_URL_PREFIX +
+            "login?uuid={uuid}&devType=6&devCode={uuid}&devModel=chrome&devVersion=127&appVersion=&timestamp={ts}&appToken=&extra=2";
+
+    private static final String TOKEN_VERIFY_URL = API_URL0 +
+            "/app/user/info/map?devType=6&devModel=Chrome&uuid={uuid}&extra=2&timestamp={ts}";
 
     private static final String SECOND_REQUEST_URL = API_URL_PREFIX + "file/redirect?downloadId={fidEncode}&enable=1" +
             "&devType=6&uuid={uuid}&timestamp={ts}&auth={auth}&shareId={dataKey}";
-    // https://api.feijipan.com/ws/file/redirect?downloadId={fidEncode}&enable=1&devType=6&uuid={uuid}&timestamp={ts}&auth={auth}&shareId={dataKey}
+
+    //https://api.feijipan.com/ws/file/redirect?
+    // downloadId=DBD34FFEDB71708FA5C284527F78E9EC104A9667FFEEA62CB6E00B54A3E0F5BB
+    // &enable=1
+    // &devType=6
+    // &uuid=rTaNVSgmwY5MbEEuiMmQL
+    // &timestamp=839E6B5E19223B8DF730A52F44062D48
+    // &auth=F799422BCD9D05D7CCC5C9C53C1092C7029B420536135C3B4B7E064F49459DCC
+    // &shareId=4wF7grHR
+    private static final String SECOND_REQUEST_URL_VIP = API_URL_PREFIX +
+            "file/redirect?downloadId={fidEncode}&enable=1&devType=6&uuid={uuid}&timestamp={ts}&auth={auth}&shareId={dataKey}";
 
 
     private static final String VIP_REQUEST_URL = API_URL_PREFIX + "/buy/vip/list?devType=6&devModel=Chrome&uuid" +
             "={uuid}&extra=2&timestamp={ts}";
     // https://api.feijipan.com/ws/buy/vip/list?devType=6&devModel=Chrome&uuid=WQAl5yBy1naGudJEILBvE&extra=2&timestamp=E2C53155F6D09417A27981561134CB73
 
-    // https://api.feijipan.com/ws/share/list?devType=6&devModel=Chrome&uuid=pwRWqwbk1J-KMTlRZowrn&extra=2&timestamp=C5F8A68C53121AB21FA35BA3529E8758&shareId=fmAuOh3m&folderId=28986333&offset=1&limit=60
-
     private static final String FILE_LIST_URL = API_URL_PREFIX + "/share/list?devType=6&devModel=Chrome&uuid" +
             "={uuid}&extra=2&timestamp={ts}&shareId={shareId}&folderId" +
             "={folderId}&offset=1&limit=60";
 
     private static final MultiMap header;
-
+    private static final MultiMap header0;
 
     long nowTs = System.currentTimeMillis();
     String tsEncode = AESUtils.encrypt2Hex(Long.toString(nowTs));
     String uuid = UUIDUtil.fjUuid(); // 也可以使用 UUID.randomUUID().toString()
 
     static {
-        header = MultiMap.caseInsensitiveMultiMap();
-        header.set("Accept", "application/json, text/plain, */*");
-        header.set("Accept-Encoding", "gzip, deflate, br, zstd");
-        header.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8");
-        header.set("Cache-Control", "no-cache");
-        header.set("Connection", "keep-alive");
-        header.set("Content-Length", "0");
-        header.set("DNT", "1");
-        header.set("Host", "api.feijipan.com");
-        header.set("Origin", "https://www.feijix.com");
-        header.set("Pragma", "no-cache");
-        header.set("Referer", "https://www.feijix.com/");
-        header.set("Sec-Fetch-Dest", "empty");
-        header.set("Sec-Fetch-Mode", "cors");
-        header.set("Sec-Fetch-Site", "cross-site");
-        header.set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
-        header.set("sec-ch-ua", "\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"");
-        header.set("sec-ch-ua-mobile", "?0");
-        header.set("sec-ch-ua-platform", "\"Windows\"");
+        header0 = MultiMap.caseInsensitiveMultiMap();
+        header0.set("Accept-Encoding", "gzip, deflate");
+        header0.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8");
+        header0.set("Cache-Control", "no-cache");
+        header0.set("Connection", "keep-alive");
+        header0.set("Content-Length", "0");
+        header0.set("DNT", "1");
+        header0.set("Pragma", "no-cache");
+        header0.set("Referer", "https://www.feijipan.com/");
+        header0.set("Sec-Fetch-Dest", "empty");
+        header0.set("Sec-Fetch-Mode", "cors");
+        header0.set("Sec-Fetch-Site", "cross-site");
+        header0.set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
+        header0.set("sec-ch-ua", "\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"");
+        header0.set("sec-ch-ua-mobile", "?0");
+        header0.set("sec-ch-ua-platform", "\"Windows\"");
+
+        header = HeaderUtils.parseHeaders("""
+                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;q=0.8,en-GB;q=0.7,en-US;q=0.6
+                Cache-Control: no-cache
+                Connection: keep-alive
+                DNT: 1
+                Pragma: no-cache
+                Referer: https://www.feijix.com/
+                Sec-Fetch-Dest: document
+                Sec-Fetch-Mode: navigate
+                Sec-Fetch-Site: cross-site
+                Sec-Fetch-User: ?1
+                Upgrade-Insecure-Requests: 1
+                user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0
+                sec-ch-ua: "Microsoft Edge";v="135", "Not-A.Brand";v="8", "Chromium";v="135"
+                sec-ch-ua-mobile: ?0
+                sec-ch-ua-platform: "Windows"
+                """);
     }
 
+    // String uuid = UUID.randomUUID().toString().toLowerCase(); // 也可以使用 UUID.randomUUID().toString()
+
+    static String token = null;
+    static String userId = null;
+    public static boolean authFlag = true;
+
     public FjTool(ShareLinkInfo shareLinkInfo) {
         super(shareLinkInfo);
     }
 
-    @Override
     public Future<String> parse() {
 
-        // 240530 此处shareId又改为了原始的shareId
-        // String.valueOf(AESUtils.idEncrypt(dataKey));
-        final String shareId = shareLinkInfo.getShareKey();
+        String shareId = shareLinkInfo.getShareKey(); // String.valueOf(AESUtils.idEncrypt(dataKey));
+        long nowTs = System.currentTimeMillis();
+        String tsEncode = AESUtils.encrypt2Hex(Long.toString(nowTs));
+
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+            // 获取用户id
+            if (auths.contains("userId")) {
+                FjTool.userId = auths.get("userId");
+                log.info("已配置用户ID: {}", FjTool.userId);
+            } else {
+                log.warn("未配置用户ID, 可能会导致解析失败");
+            }
+        }
 
         // 24.5.12 飞机盘 规则修改 需要固定UUID先请求会员接口, 再请求后续接口
         String url = StringUtils.isBlank(shareLinkInfo.getSharePassword()) ? FIRST_REQUEST_URL
@@ -98,77 +142,312 @@ public class FjTool extends PanBase {
                 .setTemplateParam("uuid", uuid)
                 .setTemplateParam("ts", tsEncode)
                 .send().onSuccess(r0 -> { // 忽略res
-
                     // 第一次请求 获取文件信息
                     // POST https://api.feijipan.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
                     client.postAbs(UriTemplate.of(url))
-                            .putHeaders(header)
+                            .putHeaders(header0)
                             .setTemplateParam("shareId", shareId)
                             .setTemplateParam("uuid", uuid)
                             .setTemplateParam("ts", tsEncode)
                             .send().onSuccess(res -> {
-                                JsonObject resJson = asJson(res);
-                                if (resJson.getInteger("code") != 200) {
-                                    fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
+
+                                JsonObject resJson;
+                                try {
+                                    resJson = asJson(res);
+                                } catch (Exception e) {
+                                    log.error("获取文件信息失败: {}", res.bodyAsString());
                                     return;
                                 }
-                                if (resJson.getJsonArray("list").isEmpty()) {
-                                    fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
+                                if (resJson.getInteger("code") != 200) {
+                                    fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
                                     return;
                                 }
                                 if (!resJson.containsKey("list") || resJson.getJsonArray("list").isEmpty()) {
                                     fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
                                     return;
                                 }
+
                                 // 文件Id
                                 JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
                                 // 如果是目录返回目录ID
-                                if (!fileInfo.containsKey("fileList") || fileInfo.getJsonArray("fileList").isEmpty()) {
-                                    fail(FIRST_REQUEST_URL + " 文件列表为空: " + fileInfo);
-                                    return;
-                                }
                                 JsonObject fileList = fileInfo.getJsonArray("fileList").getJsonObject(0);
                                 if (fileList.getInteger("fileType") == 2) {
                                     promise.complete(fileList.getInteger("folderId").toString());
                                     return;
                                 }
+                                // 提取文件信息
+                                extractFileInfo(fileList, fileInfo);
+                                getDownURL(resJson);
+                            }).onFailure(handleFail("请求1"));
 
-                                String fileId = fileInfo.getString("fileIds");
-                                String userId = fileInfo.getString("userId");
-                                // 其他参数
-                                long nowTs2 = System.currentTimeMillis();
-                                String tsEncode2 = AESUtils.encrypt2Hex(Long.toString(nowTs2));
-                                String fidEncode = AESUtils.encrypt2Hex(fileId + "|" + userId);
-                                String auth = AESUtils.encrypt2Hex(fileId + "|" + nowTs2);
-
-                                // 第二次请求
-                                HttpRequest<Buffer> httpRequest =
-                                        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
-                                        .putHeaders(header)
-                                        .setTemplateParam("fidEncode", fidEncode)
-                                        .setTemplateParam("uuid", uuid)
-                                        .setTemplateParam("ts", tsEncode2)
-                                        .setTemplateParam("auth", auth)
-                                        .setTemplateParam("dataKey", shareId);
-                                // System.out.println(httpRequest.toString());
-                                httpRequest.send().onSuccess(res2 -> {
-                                    MultiMap headers = res2.headers();
-                                    if (!headers.contains("Location")) {
-                                        fail(SECOND_REQUEST_URL + " 未找到重定向URL: \n" + res.headers());
-                                        return;
-                                    }
-                                    promise.complete(headers.get("Location"));
-                                }).onFailure(handleFail(SECOND_REQUEST_URL));
-                            }).onFailure(handleFail(FIRST_REQUEST_URL));
-
-                }).onFailure(handleFail(FIRST_REQUEST_URL));
+                }).onFailure(handleFail("请求1"));
 
         return promise.future();
     }
 
+    private void getDownURL(JsonObject resJson) {
+        String dataKey = shareLinkInfo.getShareKey();
+        // 文件Id
+        JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
+        String fileId = fileInfo.getString("fileIds");
+        String userId = fileInfo.getString("userId");
+        // 其他参数
+        long nowTs2 = System.currentTimeMillis();
+        String tsEncode2 = AESUtils.encrypt2Hex(Long.toString(nowTs2));
+        String fidEncode = AESUtils.encrypt2Hex(fileId + "|" + FjTool.userId);
+        String auth = AESUtils.encrypt2Hex(fileId + "|" + nowTs2);
+
+        // 检查是否有认证信息
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            // 检查是否为临时认证（临时认证每次都尝试登录）
+            boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+            // 如果是临时认证，或者是后台配置且authFlag为true，则尝试使用认证
+            if (isTempAuth || authFlag) {
+                log.debug("尝试使用认证信息解析, isTempAuth={}, authFlag={}", isTempAuth, authFlag);
+                HttpRequest<Buffer> httpRequest =
+                        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL_VIP))
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode2)
+                                .setTemplateParam("auth", auth)
+                                .setTemplateParam("dataKey", dataKey)
+                        ;
+                MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+                if (token == null) {
+                    // 执行登录
+                    login(tsEncode2, auths).onFailure(failRes-> {
+                        log.warn("登录失败: {}", failRes.getMessage());
+                        fail(failRes.getMessage());
+                    }).onSuccess(r-> {
+                        httpRequest.setTemplateParam("fidEncode", AESUtils.encrypt2Hex(fileId + "|" + FjTool.userId))
+                                .putHeaders(header);
+                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                    });
+                } else {
+                    // 验证token
+                    client.postAbs(UriTemplate.of(TOKEN_VERIFY_URL))
+                            .setTemplateParam("uuid", uuid)
+                            .setTemplateParam("ts", tsEncode2)
+                            .putHeaders(header0).send().onSuccess(res -> {
+                                if (asJson(res).getInteger("code") != 200) {
+                                    login(tsEncode2, auths).onFailure(failRes -> {
+                                        log.warn("重新登录失败: {}", failRes.getMessage());
+                                        fail(failRes.getMessage());
+                                    }).onSuccess(r-> {
+                                        httpRequest
+                                                .setTemplateParam("fidEncode", fidEncode)
+                                                .putHeaders(header);
+                                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                    });
+                                } else {
+                                    httpRequest
+                                            .setTemplateParam("fidEncode", AESUtils.encrypt2Hex(fileId + "|" + FjTool.userId))
+                                            .putHeaders(header);
+                                    httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                }
+                            }).onFailure(handleFail("Token验证"));
+                }
+            } else {
+                // authFlag 为 false，使用免登录解析
+                log.debug("authFlag=false，使用免登录解析");
+                clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                        .putHeaders(header)
+                        .setTemplateParam("fidEncode", fidEncode)
+                        .setTemplateParam("uuid", uuid)
+                        .setTemplateParam("ts", tsEncode2)
+                        .setTemplateParam("auth", auth)
+                        .setTemplateParam("dataKey", dataKey).send()
+                        .onSuccess(this::down).onFailure(handleFail("请求2"));
+            }
+        } else {
+            // 没有认证信息，使用免登录解析
+            log.debug("无认证信息，使用免登录解析");
+            clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                    .putHeaders(header)
+                    .setTemplateParam("fidEncode", fidEncode)
+                    .setTemplateParam("uuid", uuid)
+                    .setTemplateParam("ts", tsEncode2)
+                    .setTemplateParam("auth", auth)
+                    .setTemplateParam("dataKey", dataKey).send()
+                    .onSuccess(this::down).onFailure(handleFail("请求2"));
+        }
+
+    }
+
+    private Future<Void> login(String tsEncode2, MultiMap auths) {
+        Promise<Void> promise1 = Promise.promise();
+        // 如果配置了用户ID 则不登录
+        if (FjTool.userId != null) {
+            promise1.complete();
+            return promise1.future();
+        }
+        client.postAbs(UriTemplate.of(LOGIN_URL))
+                .setTemplateParam("uuid",uuid)
+                .setTemplateParam("ts", tsEncode2)
+                .putHeaders(header0)
+                .sendJsonObject(JsonObject.of("loginName", auths.get("username"), "loginPwd", auths.get("password")))
+                .onSuccess(res2->{
+                    JsonObject json = asJson(res2);
+                    if (json.getInteger("code") == 200) {
+                        token = json.getJsonObject("data").getString("appToken");
+                        header0.set("appToken", token);
+                        log.info("登录成功 token: {}", token);
+                        client.postAbs(UriTemplate.of(TOKEN_VERIFY_URL))
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode2)
+                                .putHeaders(header0).send().onSuccess(res -> {
+                                    if (asJson(res).getInteger("code") == 200) {
+                                        if (FjTool.userId == null) {
+                                            FjTool.userId = asJson(res).getJsonObject("map").getString("userId");
+                                        }
+                                        log.info("验证成功 userId: {}", FjTool.userId);
+                                        promise1.complete();
+                                    } else {
+                                        promise1.fail("验证失败: " + res.bodyAsString());
+                                    }
+                                });
+                    } else {
+                        // 检查是否为临时认证
+                        boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+                        if (isTempAuth) {
+                            // 临时认证失败，直接返回错误，不影响后台配置的认证
+                            log.warn("临时认证失败: {}", json.getString("msg"));
+                            promise1.fail("临时认证失败: " + json.getString("msg"));
+                        } else {
+                            // 后台配置的认证失败，设置authFlag并返回失败，让下次请求使用免登陆解析
+                            log.warn("后台配置认证失败: {}, authFlag将设为false，请重新解析", json.getString("msg"));
+                            authFlag = false;
+                            promise1.fail("认证失败: " + json.getString("msg") + ", 请重新解析将使用免登陆模式");
+                        }
+                    }
+                }).onFailure(err -> {
+                    log.error("登录请求异常: {}", err.getMessage());
+                    promise1.fail("登录请求异常: " + err.getMessage());
+                });
+        return promise1.future();
+    }
+
+    /**
+     * 从接口返回数据中提取文件信息
+     */
+    private void extractFileInfo(JsonObject fileList, JsonObject shareInfo) {
+        try {
+            // 文件名
+            String fileName = fileList.getString("fileName");
+            shareLinkInfo.getOtherParam().put("fileName", fileName);
+            
+            // 文件大小 (KB -> Bytes)
+            Long fileSize = fileList.getLong("fileSize", 0L) * 1024;
+            shareLinkInfo.getOtherParam().put("fileSize", fileSize);
+            shareLinkInfo.getOtherParam().put("fileSizeFormat", FileSizeConverter.convertToReadableSize(fileSize));
+            
+            // 文件图标
+            String fileIcon = fileList.getString("fileIcon");
+            if (StringUtils.isNotBlank(fileIcon)) {
+                shareLinkInfo.getOtherParam().put("fileIcon", fileIcon);
+            }
+            
+            // 文件ID
+            Long fileId = fileList.getLong("fileId");
+            if (fileId != null) {
+                shareLinkInfo.getOtherParam().put("fileId", fileId.toString());
+            }
+            
+            // 文件类型 (1=文件, 2=目录)
+            Integer fileType = fileList.getInteger("fileType", 1);
+            shareLinkInfo.getOtherParam().put("fileType", fileType == 1 ? "file" : "folder");
+            
+            // 下载次数
+            Integer downloads = fileList.getInteger("fileDownloads", 0);
+            shareLinkInfo.getOtherParam().put("downloadCount", downloads);
+            
+            // 点赞数
+            Integer likes = fileList.getInteger("fileLikes", 0);
+            shareLinkInfo.getOtherParam().put("likeCount", likes);
+            
+            // 评论数
+            Integer comments = fileList.getInteger("fileComments", 0);
+            shareLinkInfo.getOtherParam().put("commentCount", comments);
+            
+            // 评分
+            Double stars = fileList.getDouble("fileStars", 0.0);
+            shareLinkInfo.getOtherParam().put("stars", stars);
+            
+            // 更新时间
+            String updateTime = fileList.getString("updTime");
+            if (StringUtils.isNotBlank(updateTime)) {
+                shareLinkInfo.getOtherParam().put("updateTime", updateTime);
+            }
+            
+            // 创建时间
+            String createTime = null;
+            
+            // 分享信息
+            if (shareInfo != null) {
+                // 分享ID
+                Integer shareId = shareInfo.getInteger("shareId");
+                if (shareId != null) {
+                    shareLinkInfo.getOtherParam().put("shareId", shareId.toString());
+                }
+                
+                // 上传时间
+                String addTime = shareInfo.getString("addTime");
+                if (StringUtils.isNotBlank(addTime)) {
+                    shareLinkInfo.getOtherParam().put("createTime", addTime);
+                    createTime = addTime;
+                }
+                
+                // 预览次数
+                Integer previewNum = shareInfo.getInteger("previewNum", 0);
+                shareLinkInfo.getOtherParam().put("previewCount", previewNum);
+                
+                // 用户信息
+                JsonObject userMap = shareInfo.getJsonObject("map");
+                if (userMap != null) {
+                    String userName = userMap.getString("userName");
+                    if (StringUtils.isNotBlank(userName)) {
+                        shareLinkInfo.getOtherParam().put("userName", userName);
+                    }
+                    
+                    // VIP信息
+                    Integer isVip = userMap.getInteger("isVip", 0);
+                    shareLinkInfo.getOtherParam().put("isVip", isVip == 1);
+                }
+            }
+            
+            // 创建 FileInfo 对象并存入 otherParam
+            FileInfo fileInfoObj = new FileInfo()
+                    .setPanType(shareLinkInfo.getType())
+                    .setFileName(fileName)
+                    .setFileId(fileId != null ? fileId.toString() : null)
+                    .setSize(fileSize)
+                    .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                    .setFileType(fileType == 1 ? "file" : "folder")
+                    .setFileIcon(fileIcon)
+                    .setDownloadCount(downloads)
+                    .setCreateTime(createTime)
+                    .setUpdateTime(updateTime);
+            shareLinkInfo.getOtherParam().put("fileInfo", fileInfoObj);
+            
+            log.debug("提取文件信息成功: fileName={}, fileSize={}, downloads={}", 
+                    fileName, fileSize, downloads);
+        } catch (Exception e) {
+            log.warn("提取文件信息失败: {}", e.getMessage());
+        }
+    }
+
+    private void down(HttpResponse<Buffer> res2) {
+        MultiMap headers = res2.headers();
+        if (!headers.contains("Location") || headers.get("Location") == null) {
+            fail("找不到下载链接可能服务器已被禁止或者配置的认证信息有误: " + res2.bodyAsString());
+            return;
+        }
+        promise.complete(headers.get("Location"));
+    }
+
+    // 目录解析
     @Override
     public Future<List<FileInfo>> parseFileList() {
-        Promise<List<FileInfo>> promise = Promise.promise();
+        Promise<List<FileInfo>> promise0 = Promise.promise();
 
         String shareId = shareLinkInfo.getShareKey(); // String.valueOf(AESUtils.idEncrypt(dataKey));
 
@@ -176,42 +455,52 @@ public class FjTool extends PanBase {
         String dirId = (String) shareLinkInfo.getOtherParam().get("dirId");
         if (dirId != null && !dirId.isEmpty()) {
             uuid = shareLinkInfo.getOtherParam().get("uuid").toString();
-            parserDir(dirId, shareId, promise);
-            return promise.future();
+            parserDir(dirId, shareId, promise0);
+            return promise0.future();
         }
         parse().onSuccess(id -> {
-            if (id != null && id.matches("^[a-zA-Z0-9]+$")) {
-                parserDir(id, shareId, promise);
-            } else {
-                promise.fail("解析目录ID失败");
-            }
+            parserDir(id, shareId, promise0);
         }).onFailure(failRes -> {
             log.error("解析目录失败: {}", failRes.getMessage());
-            promise.fail(failRes);
+            promise0.fail(failRes);
         });
-        return promise.future();
+        return promise0.future();
     }
 
     private void parserDir(String id, String shareId, Promise<List<FileInfo>> promise) {
+        // id以http开头直接返回 封装数组返回
+        if (id != null && (id.startsWith("http://") || id.startsWith("https://"))) {
+            FileInfo fileInfo = new FileInfo();
+            fileInfo.setFileName(id)
+                    .setFileId(id)
+                    .setFileType("file")
+                    .setParserUrl(id)
+                    .setPanType(shareLinkInfo.getType());
+            List<FileInfo> result = new ArrayList<>();
+            result.add(fileInfo);
+            promise.complete(result);
+            return;
+        }
+
         log.debug("开始解析目录: {}, shareId: {}, uuid: {}, ts: {}", id, shareId, uuid, tsEncode);
         // 开始解析目录: 164312216, shareId: bPMsbg5K, uuid: 0fmVWTx2Ea4zFwkpd7KXf, ts: 20865d7b7f00828279f437cd1f097860
         // 拿到目录ID
         client.postAbs(UriTemplate.of(FILE_LIST_URL))
-                .putHeaders(header)
+                .putHeaders(header0)
                 .setTemplateParam("shareId", shareId)
                 .setTemplateParam("uuid", uuid)
                 .setTemplateParam("ts", tsEncode)
                 .setTemplateParam("folderId", id)
                 .send().onSuccess(res -> {
-                    JsonObject jsonObject;
+                    JsonArray list;
                     try {
-                        jsonObject = asJson(res);
+                        JsonObject jsonObject = asJson(res);
+                        System.out.println(jsonObject.encodePrettily());
+                        list = jsonObject.getJsonArray("list");
                     } catch (Exception e) {
-                        promise.fail(FIRST_REQUEST_URL + " 解析JSON失败: " + res.bodyAsString());
+                        log.error("解析目录失败: {}", res.bodyAsString());
                         return;
                     }
-                    // System.out.println(jsonObject.encodePrettily());
-                    JsonArray list = jsonObject.getJsonArray("list");
                     ArrayList<FileInfo> result = new ArrayList<>();
                     list.forEach(item->{
                         JsonObject fileJson = (JsonObject) item;
@@ -224,7 +513,7 @@ public class FjTool extends PanBase {
                         // 其他参数
                         long nowTs2 = System.currentTimeMillis();
                         String tsEncode2 = AESUtils.encrypt2Hex(Long.toString(nowTs2));
-                        String fidEncode = AESUtils.encrypt2Hex(fileId + "|" + userId);
+                        String fidEncode = AESUtils.encrypt2Hex(fileId + "|" + FjTool.userId);
                         String auth = AESUtils.encrypt2Hex(fileId + "|" + nowTs2);
 
                         // 回传用到的参数
@@ -239,8 +528,7 @@ public class FjTool extends PanBase {
                                 "ts", tsEncode2,
                                 "auth", auth,
                                 "shareId", shareId);
-                        byte[] encode = Base64.getEncoder().encode(entries.encode().getBytes());
-                        String param = new String(encode);
+                        String param = CommonUtils.urlBase64Encode(entries.encode());
 
                         if (fileJson.getInteger("fileType") == 2) {
                             // 如果是目录
@@ -280,17 +568,15 @@ public class FjTool extends PanBase {
                         result.add(fileInfo);
                     });
                     promise.complete(result);
-                }).onFailure(failRes -> {
-                    log.error("解析目录请求失败: {}", failRes.getMessage());
-                    promise.fail(failRes);
-                });;
+                });
     }
 
     @Override
     public Future<String> parseById() {
+
         // 第二次请求
         JsonObject paramJson = (JsonObject)shareLinkInfo.getOtherParam().get("paramJson");
-        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL_VIP))
                 .setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
                 .setTemplateParam("uuid", paramJson.getString("uuid"))
                 .setTemplateParam("ts", paramJson.getString("ts"))
@@ -299,11 +585,16 @@ public class FjTool extends PanBase {
                 .putHeaders(header).send().onSuccess(res2 -> {
                     MultiMap headers = res2.headers();
                     if (!headers.contains("Location")) {
-                        fail(SECOND_REQUEST_URL + " 未找到重定向URL: \n" + res2.headers());
+                        fail(SECOND_REQUEST_URL_VIP + " 未找到重定向URL: \n" + res2.headers());
                         return;
                     }
                     promise.complete(headers.get("Location"));
-                }).onFailure(handleFail(SECOND_REQUEST_URL));
+                }).onFailure(handleFail(SECOND_REQUEST_URL_VIP));
         return promise.future();
     }
+
+    public static void resetToken() {
+        token = null;
+        authFlag = true;
+    }
 }

parser/src/main/java/cn/qaiu/parser/impl/FsTool.java

@@ -0,0 +1,492 @@
+package cn.qaiu.parser.impl;
+
+import cn.qaiu.entity.FileInfo;
+import cn.qaiu.entity.ShareLinkInfo;
+import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.CommonUtils;
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * <a href="https://www.feishu.cn/">飞书云盘</a>
+ * <p>
+ * 支持飞书公开分享文件和文件夹的解析。
+ * <ul>
+ *     <li>文件链接: https://xxx.feishu.cn/file/{token}</li>
+ *     <li>文件夹链接: https://xxx.feishu.cn/drive/folder/{token}</li>
+ * </ul>
+ * 飞书下载需要先获取匿名会话Cookie，然后使用Cookie请求下载接口。
+ * </p>
+ */
+public class FsTool extends PanBase {
+
+    private static final String UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            + "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36";
+
+    /**
+     * 飞书 obj_type: type=12 表示上传文件可下载
+     */
+    private static final int OBJ_TYPE_FILE = 12;
+
+    /**
+     * v3 列表 API 支持的 obj_type
+     */
+    private static final int[] LIST_OBJ_TYPES = {
+            0, 2, 22, 44, 3, 30, 8, 11, 12, 84, 123, 124
+    };
+
+    /** 每页返回条目数 */
+    private static final int PAGE_SIZE = 50;
+
+    /**
+     * 从分享链接中提取 tenant 的正则
+     */
+    private static final Pattern TENANT_PATTERN =
+            Pattern.compile("https://([^.]+)\\.feishu\\.cn/");
+
+    /** 解析 Content-Disposition: filename*=UTF-8''xxx */
+    private static final Pattern CD_FILENAME_STAR_PATTERN =
+            Pattern.compile("filename\\*=UTF-8''(.+?)(?:;|$)");
+
+    /** 解析 Content-Disposition: filename="xxx" 或 filename=xxx */
+    private static final Pattern CD_FILENAME_PATTERN =
+            Pattern.compile("filename=\"?([^\";]+)\"?");
+
+    /** 解析 Content-Range 中的总大小 */
+    private static final Pattern CONTENT_RANGE_SIZE_PATTERN =
+            Pattern.compile("/(\\d+)");
+
+    public FsTool(ShareLinkInfo shareLinkInfo) {
+        super(shareLinkInfo);
+    }
+
+    @Override
+    public Future<String> parse() {
+        String shareUrl = shareLinkInfo.getShareUrl();
+        String tenant = extractTenant(shareUrl);
+        String token = shareLinkInfo.getShareKey();
+
+        if (tenant == null || token == null) {
+            fail("无法从链接中提取tenant或token: {}", shareUrl);
+            return promise.future();
+        }
+
+        boolean isFolder = shareUrl.contains("/drive/folder/");
+        if (isFolder) {
+            fetchSessionAndParseFolder(tenant, token, shareUrl);
+        } else {
+            fetchSessionAndParseFile(tenant, token, shareUrl);
+        }
+
+        return promise.future();
+    }
+
+    /**
+     * 获取匿名session后解析文件
+     */
+    private void fetchSessionAndParseFile(String tenant, String token, String shareUrl) {
+        clientSession.getAbs(shareUrl)
+                .putHeader("User-Agent", UA)
+                .putHeader("Accept", "text/html,*/*")
+                .send()
+                .onSuccess(res -> {
+                    String dlUrl = buildDownloadUrl(tenant, token);
+
+                    // Range探测获取文件名和大小
+                    clientSession.getAbs(dlUrl)
+                            .putHeader("User-Agent", UA)
+                            .putHeader("Referer", shareUrl)
+                            .putHeader("Range", "bytes=0-0")
+                            .send()
+                            .onSuccess(probeRes -> {
+                                String fileName = parseFileNameFromContentDisposition(
+                                        probeRes.getHeader("Content-Disposition"));
+
+                                Map<String, String> headers = new HashMap<>();
+                                headers.put("Referer", shareUrl);
+                                headers.put("User-Agent", UA);
+
+                                String cookies = extractCookiesFromResponse(probeRes);
+                                if (cookies != null && !cookies.isEmpty()) {
+                                    headers.put("Cookie", cookies);
+                                }
+
+                                if (fileName != null) {
+                                    FileInfo fileInfo = new FileInfo();
+                                    fileInfo.setFileName(fileName);
+                                    fileInfo.setFileId(token);
+                                    fileInfo.setFileType("file");
+                                    fileInfo.setPanType(shareLinkInfo.getType());
+                                    fileInfo.setParserUrl(buildRedirectUrl(shareUrl, token));
+                                    parseSizeFromContentRange(
+                                            probeRes.getHeader("Content-Range"), fileInfo);
+                                    shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
+                                }
+
+                                completeWithMeta(dlUrl, headers);
+                            })
+                            .onFailure(handleFail("探测文件信息失败"));
+                })
+                .onFailure(handleFail("获取匿名会话失败"));
+    }
+
+    /**
+     * 获取匿名session后解析文件夹（取第一个可下载文件）
+     */
+    private void fetchSessionAndParseFolder(String tenant, String folderToken,
+                                             String shareUrl) {
+        clientSession.getAbs(shareUrl)
+                .putHeader("User-Agent", UA)
+                .putHeader("Accept", "text/html,*/*")
+                .send()
+                .onSuccess(res ->
+                        listFolderAll(tenant, folderToken, "").onSuccess(items -> {
+                            if (items.isEmpty()) {
+                                fail("文件夹中没有可下载的文件");
+                                return;
+                            }
+                            FileInfo first = items.get(0);
+                            String objToken = first.getFileId();
+                            String dlUrl = buildDownloadUrl(tenant, objToken);
+                            String referer = "https://" + tenant
+                                    + ".feishu.cn/drive/folder/" + folderToken;
+
+                            Map<String, String> headers = new HashMap<>();
+                            headers.put("Referer", referer);
+                            headers.put("User-Agent", UA);
+
+                            shareLinkInfo.getOtherParam().put("fileInfo", first);
+                            completeWithMeta(dlUrl, headers);
+                        }).onFailure(t -> fail("列出文件夹内容失败: {}", t.getMessage())))
+                .onFailure(handleFail("获取匿名会话失败"));
+    }
+
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        Promise<List<FileInfo>> listPromise = Promise.promise();
+        String shareUrl = shareLinkInfo.getShareUrl();
+        String tenant = extractTenant(shareUrl);
+        String token = shareLinkInfo.getShareKey();
+
+        if (tenant == null || token == null) {
+            listPromise.fail("无法从链接中提取tenant或token: " + shareUrl);
+            return listPromise.future();
+        }
+
+        boolean isFolder = shareUrl.contains("/drive/folder/");
+
+        clientSession.getAbs(shareUrl)
+                .putHeader("User-Agent", UA)
+                .putHeader("Accept", "text/html,*/*")
+                .send()
+                .onSuccess(res -> {
+                    if (isFolder) {
+                        listFolderAll(tenant, token, "")
+                                .onSuccess(listPromise::complete)
+                                .onFailure(listPromise::fail);
+                    } else {
+                        probeSingleFile(tenant, token, shareUrl)
+                                .onSuccess(fileInfo -> {
+                                    List<FileInfo> list = new ArrayList<>();
+                                    list.add(fileInfo);
+                                    listPromise.complete(list);
+                                })
+                                .onFailure(listPromise::fail);
+                    }
+                })
+                .onFailure(t -> listPromise.fail("获取匿名会话失败: " + t.getMessage()));
+
+        return listPromise.future();
+    }
+
+    /**
+     * 分页获取文件夹所有可下载文件
+     */
+    private Future<List<FileInfo>> listFolderAll(String tenant, String folderToken,
+                                                  String pageLabel) {
+        Promise<List<FileInfo>> p = Promise.promise();
+
+        listFolderPage(tenant, folderToken, pageLabel).onSuccess(pageResult -> {
+            List<FileInfo> items = new ArrayList<>(pageResult.items);
+            if (pageResult.hasMore) {
+                listFolderAll(tenant, folderToken, pageResult.nextLabel)
+                        .onSuccess(moreItems -> {
+                            items.addAll(moreItems);
+                            p.complete(items);
+                        })
+                        .onFailure(p::fail);
+            } else {
+                p.complete(items);
+            }
+        }).onFailure(p::fail);
+
+        return p.future();
+    }
+
+    /**
+     * 列出文件夹内容（单页）
+     */
+    private Future<FolderPageResult> listFolderPage(String tenant, String folderToken,
+                                                     String pageLabel) {
+        Promise<FolderPageResult> p = Promise.promise();
+        String baseUrl = "https://" + tenant + ".feishu.cn";
+
+        StringBuilder urlBuilder = new StringBuilder();
+        urlBuilder.append(baseUrl)
+                .append("/space/api/explorer/v3/children/list/")
+                .append("?length=").append(PAGE_SIZE)
+                .append("&asc=1&rank=5&token=").append(folderToken);
+
+        for (int type : LIST_OBJ_TYPES) {
+            urlBuilder.append("&obj_type=").append(type);
+        }
+
+        if (pageLabel != null && !pageLabel.isEmpty()) {
+            urlBuilder.append("&last_label=").append(pageLabel);
+        }
+
+        String url = urlBuilder.toString();
+        String referer = baseUrl + "/drive/folder/" + folderToken;
+
+        clientSession.getAbs(url)
+                .putHeader("User-Agent", UA)
+                .putHeader("Accept", "application/json, text/plain, */*")
+                .putHeader("Referer", referer)
+                .send()
+                .onSuccess(res -> {
+                    try {
+                        JsonObject json = asJson(res);
+                        int code = json.getInteger("code", -1);
+                        if (code != 0) {
+                            p.fail("飞书API错误: " + json.getString("msg"));
+                            return;
+                        }
+
+                        JsonObject data = json.getJsonObject("data");
+                        JsonObject entities = data.getJsonObject("entities",
+                                new JsonObject());
+                        JsonObject nodes = entities.getJsonObject("nodes",
+                                new JsonObject());
+                        JsonArray nodeList = data.getJsonArray("node_list",
+                                new JsonArray());
+
+                        List<FileInfo> items = new ArrayList<>();
+                        for (int i = 0; i < nodeList.size(); i++) {
+                            String nid = nodeList.getString(i);
+                            JsonObject node = nodes.getJsonObject(nid,
+                                    new JsonObject());
+                            int objType = node.getInteger("type", -1);
+                            String objToken = node.getString("obj_token", "");
+                            String name = node.getString("name", "unknown");
+
+                            // 排除文件夹自身节点
+                            if (objToken.equals(folderToken)) {
+                                continue;
+                            }
+
+                            // 只返回可下载的文件(type=12)
+                            if (objType == OBJ_TYPE_FILE) {
+                                FileInfo fileInfo = new FileInfo();
+                                fileInfo.setFileName(name);
+                                fileInfo.setFileId(objToken);
+                                fileInfo.setPanType(shareLinkInfo.getType());
+                                fileInfo.setFileType("file");
+
+                                JsonObject extra = node.getJsonObject("extra",
+                                        new JsonObject());
+                                try {
+                                    long size = Long.parseLong(
+                                            extra.getString("size", "0"));
+                                    fileInfo.setSize(size);
+                                } catch (NumberFormatException e) {
+                                    log.warn("无法解析文件大小: {}", extra.getString("size"), e);
+                                }
+
+                                fileInfo.setParserUrl(buildRedirectUrl(
+                                        shareLinkInfo.getShareUrl(), objToken));
+
+                                // 添加下载所需的请求头到extParameters
+                                Map<String, Object> extParams = new HashMap<>();
+                                Map<String, String> downloadHeaders = new HashMap<>();
+                                downloadHeaders.put("Referer", referer);
+                                downloadHeaders.put("User-Agent", UA);
+                                extParams.put("downloadHeaders", downloadHeaders);
+                                fileInfo.setExtParameters(extParams);
+
+                                items.add(fileInfo);
+                            }
+                        }
+
+                        boolean hasMore = data.getBoolean("has_more", false);
+                        String nextLabel = data.getString("last_label", "");
+
+                        p.complete(new FolderPageResult(items, hasMore, nextLabel));
+                    } catch (Exception e) {
+                        p.fail("解析文件列表响应失败: " + e.getMessage());
+                    }
+                })
+                .onFailure(t -> p.fail("请求文件列表失败: " + t.getMessage()));
+
+        return p.future();
+    }
+
+    /**
+     * 探测单个文件信息
+     */
+    private Future<FileInfo> probeSingleFile(String tenant, String token,
+                                              String referer) {
+        Promise<FileInfo> p = Promise.promise();
+        String dlUrl = buildDownloadUrl(tenant, token);
+
+        clientSession.getAbs(dlUrl)
+                .putHeader("User-Agent", UA)
+                .putHeader("Referer", referer)
+                .putHeader("Range", "bytes=0-0")
+                .send()
+                .onSuccess(probeRes -> {
+                    FileInfo fileInfo = new FileInfo();
+                    String fileName = parseFileNameFromContentDisposition(
+                            probeRes.getHeader("Content-Disposition"));
+                    if (fileName != null) {
+                        fileInfo.setFileName(fileName);
+                    }
+                    parseSizeFromContentRange(
+                            probeRes.getHeader("Content-Range"), fileInfo);
+                    fileInfo.setFileId(token);
+                    fileInfo.setPanType(shareLinkInfo.getType());
+                    fileInfo.setFileType("file");
+                    fileInfo.setParserUrl(buildRedirectUrl(referer, token));
+
+                    // 添加下载所需的请求头到extParameters
+                    Map<String, Object> extParams = new HashMap<>();
+                    Map<String, String> downloadHeaders = new HashMap<>();
+                    downloadHeaders.put("Referer", referer);
+                    downloadHeaders.put("User-Agent", UA);
+                    extParams.put("downloadHeaders", downloadHeaders);
+                    fileInfo.setExtParameters(extParams);
+
+                    p.complete(fileInfo);
+                })
+                .onFailure(t -> p.fail("探测文件失败: " + t.getMessage()));
+
+        return p.future();
+    }
+
+    @Override
+    public Future<String> parseById() {
+        Promise<String> parsePromise = Promise.promise();
+
+        try {
+            JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+            String shareUrl = paramJson.getString("shareUrl");
+            String objToken = paramJson.getString("objToken");
+            String tenant = extractTenant(shareUrl);
+
+            if (shareUrl == null || objToken == null || tenant == null) {
+                parsePromise.fail("飞书目录文件下载参数不完整");
+                return parsePromise.future();
+            }
+
+            parsePromise.complete(buildDownloadUrl(tenant, objToken));
+        } catch (Exception e) {
+            parsePromise.fail("解析飞书目录文件参数失败: " + e.getMessage());
+        }
+
+        return parsePromise.future();
+    }
+
+    // ─── 工具方法 ────────────────────────────────────────
+
+    private String buildRedirectUrl(String shareUrl, String objToken) {
+        JsonObject paramJson = new JsonObject()
+                .put("shareUrl", shareUrl)
+                .put("objToken", objToken);
+        return String.format("%s/v2/redirectUrl/%s/%s",
+                getDomainName(),
+                shareLinkInfo.getType(),
+                CommonUtils.urlBase64Encode(paramJson.encode()));
+    }
+
+    private String buildDownloadUrl(String tenant, String objToken) {
+        return "https://" + tenant
+                + ".feishu.cn/space/api/box/stream/download/all/" + objToken;
+    }
+
+    private String extractTenant(String url) {
+        if (url == null) return null;
+        Matcher m = TENANT_PATTERN.matcher(url);
+        if (m.find()) {
+            return m.group(1);
+        }
+        return null;
+    }
+
+    /**
+     * 从Content-Disposition头解析文件名。
+     * 支持 filename*=UTF-8''xxx 和 filename="xxx" 两种格式。
+     */
+    private String parseFileNameFromContentDisposition(String cd) {
+        if (cd == null || cd.isEmpty()) return null;
+
+        // 优先解析 filename*=UTF-8''xxx
+        Matcher m1 = CD_FILENAME_STAR_PATTERN.matcher(cd);
+        if (m1.find()) {
+            try {
+                return URLDecoder.decode(m1.group(1).trim(), StandardCharsets.UTF_8);
+            } catch (Exception ignored) {
+            }
+        }
+
+        // 降级解析 filename="xxx" 或 filename=xxx
+        Matcher m2 = CD_FILENAME_PATTERN.matcher(cd);
+        if (m2.find()) {
+            try {
+                return URLDecoder.decode(m2.group(1).trim(), StandardCharsets.UTF_8);
+            } catch (Exception ignored) {
+            }
+        }
+
+        return null;
+    }
+
+    private void parseSizeFromContentRange(String cr, FileInfo fileInfo) {
+        if (cr != null) {
+            Matcher m = CONTENT_RANGE_SIZE_PATTERN.matcher(cr);
+            if (m.find()) {
+                fileInfo.setSize(Long.parseLong(m.group(1)));
+            }
+        }
+    }
+
+    private String extractCookiesFromResponse(
+            io.vertx.ext.web.client.HttpResponse<?> response) {
+        List<String> setCookies = response.cookies();
+        if (setCookies == null || setCookies.isEmpty()) return null;
+
+        StringBuilder sb = new StringBuilder();
+        for (String cookie : setCookies) {
+            String nameValue = cookie.split(";")[0].trim();
+            if (!sb.isEmpty()) sb.append("; ");
+            sb.append(nameValue);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 文件夹分页结果
+     */
+    private record FolderPageResult(List<FileInfo> items, boolean hasMore,
+                                     String nextLabel) {
+    }
+}

parser/src/main/java/cn/qaiu/parser/impl/IzSelectorTool.java

@@ -0,0 +1,55 @@
+package cn.qaiu.parser.impl;
+
+import cn.qaiu.entity.FileInfo;
+import cn.qaiu.entity.ShareLinkInfo;
+import cn.qaiu.parser.IPanTool;
+import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.List;
+
+/**
+ * 蓝奏云优享解析器选择器
+ * 根据配置的鉴权方式选择不同的解析器：
+ * - 如果配置了 username 和 password，则使用 IzToolWithAuth (支持大文件)
+ * - 否则使用 IzTool (免登录，仅支持小文件)
+ */
+public class IzSelectorTool implements IPanTool {
+    private final IPanTool selectedTool;
+
+    public IzSelectorTool(ShareLinkInfo shareLinkInfo) {
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+            
+            // 检查是否配置了账号密码
+            if (auths.contains("username") && auths.contains("password")) {
+                String username = auths.get("username");
+                String password = auths.get("password");
+                if (StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {
+                    // 使用 IzToolWithAuth (账密登录，支持大文件)
+                    this.selectedTool = new IzToolWithAuth(shareLinkInfo);
+                    return;
+                }
+            }
+        }
+        
+        // 无认证信息或认证信息无效，使用免登录版本（仅支持小文件）
+        this.selectedTool = new IzTool(shareLinkInfo);
+    }
+
+    @Override
+    public Future<String> parse() {
+        return selectedTool.parse();
+    }
+
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        return selectedTool.parseFileList();
+    }
+
+    @Override
+    public Future<String> parseById() {
+        return selectedTool.parseById();
+    }
+}

parser/src/main/java/cn/qaiu/parser/impl/IzTool.java

@@ -4,17 +4,25 @@ import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.PanBase;
 import cn.qaiu.util.AESUtils;
+import cn.qaiu.util.AcwScV2Generator;
+import cn.qaiu.util.CommonUtils;
 import cn.qaiu.util.FileSizeConverter;
-import cn.qaiu.util.UUIDUtil;
+import io.netty.handler.codec.http.cookie.DefaultCookie;
 import io.vertx.core.Future;
 import io.vertx.core.MultiMap;
 import io.vertx.core.Promise;
+import io.vertx.core.buffer.Buffer;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
+import io.vertx.ext.web.client.HttpRequest;
+import io.vertx.ext.web.client.HttpResponse;
+import io.vertx.ext.web.client.WebClientSession;
 import io.vertx.uritemplate.UriTemplate;
 import org.apache.commons.lang3.StringUtils;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
 
 /**
  * 蓝奏云优享
@@ -22,14 +30,25 @@ import java.util.*;
  */
 public class IzTool extends PanBase {
 
+    private static final String API_URL0 = "https://api.ilanzou.com/";
     private static final String API_URL_PREFIX = "https://api.ilanzou.com/unproved/";
 
     private static final String FIRST_REQUEST_URL = API_URL_PREFIX + "recommend/list?devType=6&devModel=Chrome" +
             "&uuid={uuid}&extra=2&timestamp={ts}&shareId={shareId}&type=0&offset=1&limit=60";
 
+    private static final String LOGIN_URL = API_URL_PREFIX +
+            "login?uuid={uuid}&devType=6&devCode={uuid}&devModel=chrome&devVersion=127&appVersion=&timestamp={ts}&appToken=&extra=2";
+
+    // https://api.ilanzou.com/proved/user/info/map?devType=3&devModel=Chrome&uuid=TInRHH3QzRaMo-Ajl2PkJ&extra=2&timestamp=EC2C6E7F45EB21338A17A7621E0BB437
+    private static final String TOKEN_VERIFY_URL = API_URL0 +
+            "proved/user/info/map?devType=6&devModel=Chrome&uuid={uuid}&extra=2&timestamp={ts}";
+
     private static final String SECOND_REQUEST_URL = API_URL_PREFIX + "file/redirect?downloadId={fidEncode}&enable=1" +
             "&devType=6&uuid={uuid}&timestamp={ts}&auth={auth}&shareId={dataKey}";
-    // downloadId=x&enable=1&devType=6&uuid=x&timestamp=x&auth=x&shareId=lGFndCM
+
+    private static final String SECOND_REQUEST_URL_VIP = API_URL_PREFIX + "file/redirect?uuid={uuid}&devType=6&devCode={uuid}" +
+            "&devModel=chrome&devVersion=127&appVersion=&timestamp={ts}&appToken={appToken}&enable=1&downloadId={fidEncode}&auth={auth}";
+
 
     private static final String VIP_REQUEST_URL = API_URL_PREFIX + "/buy/vip/list?devType=6&devModel=Chrome&uuid" +
             "={uuid}&extra=2&timestamp={ts}";
@@ -38,16 +57,15 @@ public class IzTool extends PanBase {
             "={uuid}&extra=2&timestamp={ts}&shareId={shareId}&folderId" +
             "={folderId}&offset=1&limit=60";
 
-    long nowTs = System.currentTimeMillis();
-    String tsEncode = AESUtils.encrypt2HexIz(Long.toString(nowTs));
-    String uuid = UUID.randomUUID().toString();
+
+    WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
 
     private static final MultiMap header;
 
     static {
         header = MultiMap.caseInsensitiveMultiMap();
         header.set("Accept", "application/json, text/plain, */*");
-        header.set("Accept-Encoding", "gzip, deflate, br, zstd");
+        header.set("Accept-Encoding", "gzip, deflate");
         header.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8");
         header.set("Cache-Control", "no-cache");
         header.set("Connection", "keep-alive");
@@ -65,85 +83,377 @@ public class IzTool extends PanBase {
         header.set("sec-ch-ua-mobile", "?0");
         header.set("sec-ch-ua-platform", "\"Windows\"");
     }
-
     public IzTool(ShareLinkInfo shareLinkInfo) {
         super(shareLinkInfo);
     }
 
+    String uuid = UUID.randomUUID().toString().toLowerCase(); // 也可以使用 UUID.randomUUID().toString()
+
+    public static String token = null;
+    public static boolean authFlag = true;
+
     public Future<String> parse() {
-        String shareId = shareLinkInfo.getShareKey();
 
-        // 24.5.12 ilanzou改规则无需计算shareId
-        // String shareId = String.valueOf(AESUtils.idEncryptIz(dataKey));
+        String shareId = shareLinkInfo.getShareKey(); // String.valueOf(AESUtils.idEncrypt(dataKey));
+        long nowTs = System.currentTimeMillis();
+        String tsEncode = AESUtils.encrypt2HexIz(Long.toString(nowTs));
 
-        // 第一次请求 获取文件信息
-        // POST https://api.ilanzou.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
-        String url = StringUtils.isBlank(shareLinkInfo.getSharePassword()) ? FIRST_REQUEST_URL
-                : (FIRST_REQUEST_URL + "&code=" + shareLinkInfo.getSharePassword());
-        client.postAbs(UriTemplate.of(VIP_REQUEST_URL))
+        // 检查并输出认证状态
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+            log.info("文件解析检测到认证信息: isTempAuth={}, authFlag={}, token={}", 
+                    isTempAuth, authFlag, token != null ? "已登录(" + token.substring(0, Math.min(10, token.length())) + "...)" : "未登录");
+            
+            // 如果需要认证但还没有token，先执行登录
+            if ((isTempAuth || authFlag) && token == null) {
+                log.info("文件解析需要登录，开始执行登录流程...");
+                MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+                return login(tsEncode, auths)
+                        .compose(v -> {
+                            log.info("文件解析预登录成功，继续解析流程");
+                            return parseWithAuth(shareId, tsEncode);
+                        })
+                        .onFailure(err -> {
+                            log.warn("文件解析预登录失败: {}，尝试使用免登录模式", err.getMessage());
+                            // 登录失败，继续使用免登录模式
+                        });
+            } else if (token != null) {
+                log.info("文件解析使用已有token: {}...", token.substring(0, Math.min(10, token.length())));
+            }
+        } else {
+            log.debug("文件解析无认证信息，使用免登录模式");
+        }
+
+        return parseWithAuth(shareId, tsEncode);
+    }
+
+    private Future<String> parseWithAuth(String shareId, String tsEncode) {
+        // 24.5.12 飞机盘 规则修改 需要固定UUID先请求会员接口, 再请求后续接口
+        webClientSession.postAbs(UriTemplate.of(VIP_REQUEST_URL))
                 .setTemplateParam("uuid", uuid)
                 .setTemplateParam("ts", tsEncode)
                 .send().onSuccess(r0 -> { // 忽略res
+
+                    String url = StringUtils.isBlank(shareLinkInfo.getSharePassword()) ? FIRST_REQUEST_URL
+                            : (FIRST_REQUEST_URL + "&code=" + shareLinkInfo.getSharePassword());
                     // 第一次请求 获取文件信息
                     // POST https://api.feijipan.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
-                    client.postAbs(UriTemplate.of(url))
+                    webClientSession.postAbs(UriTemplate.of(url))
                             .putHeaders(header)
                             .setTemplateParam("shareId", shareId)
                             .setTemplateParam("uuid", uuid)
                             .setTemplateParam("ts", tsEncode)
                             .send().onSuccess(res -> {
-                                JsonObject resJson = asJson(res);
-                                if (resJson.getInteger("code") != 200) {
-                                    fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
-                                    return;
-                                }
-                                if (resJson.getJsonArray("list").isEmpty()) {
-                                    fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
-                                    return;
-                                }
-                                if (!resJson.containsKey("list") || resJson.getJsonArray("list").isEmpty()) {
-                                    fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
-                                    return;
-                                }
-                                // 文件Id
-                                JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
-                                // 如果是目录返回目录ID
-                                if (!fileInfo.containsKey("fileList") || fileInfo.getJsonArray("fileList").isEmpty()) {
-                                    fail(FIRST_REQUEST_URL + " 文件列表为空: " + fileInfo);
-                                    return;
-                                }
-                                JsonObject fileList = fileInfo.getJsonArray("fileList").getJsonObject(0);
-                                if (fileList.getInteger("fileType") == 2) {
-                                    promise.complete(fileList.getInteger("folderId").toString());
+                                String resBody = asText(res);
+                                // 检查是否包含 cookie 验证
+                                if (resBody.contains("var arg1='")) {
+                                    webClientSession = WebClientSession.create(clientNoRedirects);
+                                    setCookie(resBody);
+                                    // 重新请求
+                                    webClientSession.postAbs(UriTemplate.of(url))
+                                            .putHeaders(header)
+                                            .setTemplateParam("shareId", shareId)
+                                            .setTemplateParam("uuid", uuid)
+                                            .setTemplateParam("ts", tsEncode)
+                                            .send().onSuccess(res2 -> {
+                                                processFirstResponse(res2);
+                                            }).onFailure(handleFail("请求1-重试"));
                                     return;
                                 }
+                                processFirstResponse(res);
+                            }).onFailure(handleFail("请求1"));
+
+                }).onFailure(handleFail("请求1"));
 
-                                String fileId = fileInfo.getString("fileIds");
-                                String userId = fileInfo.getString("userId");
-                                // 其他参数
-                                // String fidEncode = AESUtils.encrypt2HexIz(fileId + "|");
-                                String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
-                                String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs);
-                                // 第二次请求
-                                clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
-                                        .setTemplateParam("fidEncode", fidEncode)
-                                        .setTemplateParam("uuid", uuid)
-                                        .setTemplateParam("ts", tsEncode)
-                                        .setTemplateParam("auth", auth)
-                                        .setTemplateParam("shareId", shareId)
-                                        .putHeaders(header).send().onSuccess(res2 -> {
-                                            MultiMap headers = res2.headers();
-                                            if (!headers.contains("Location")) {
-                                                fail(SECOND_REQUEST_URL + " 未找到重定向URL: \n" + headers);
-                                                return;
-                                            }
-                                            promise.complete(headers.get("Location"));
-                                        }).onFailure(handleFail(SECOND_REQUEST_URL));
-                            }).onFailure(handleFail(FIRST_REQUEST_URL));
-                });
         return promise.future();
     }
 
+    /**
+     * 设置 cookie
+     */
+    private void setCookie(String html) {
+        int beginIndex = html.indexOf("arg1='") + 6;
+        String arg1 = html.substring(beginIndex, html.indexOf("';", beginIndex));
+        String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
+        // 创建一个 Cookie 并放入 CookieStore
+        DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
+        nettyCookie.setDomain(".ilanzou.com"); // 设置域名
+        nettyCookie.setPath("/");             // 设置路径
+        nettyCookie.setSecure(false);
+        nettyCookie.setHttpOnly(false);
+        webClientSession.cookieStore().put(nettyCookie);
+    }
+
+    /**
+     * 处理第一次请求的响应
+     */
+    private void processFirstResponse(HttpResponse<Buffer> res) {
+        JsonObject resJson = asJson(res);
+        if (resJson.getInteger("code") != 200) {
+            fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
+            return;
+        }
+        if (!resJson.containsKey("list") || resJson.getJsonArray("list").isEmpty()) {
+            fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
+            return;
+        }
+        // 文件Id
+        JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
+        // 如果是目录返回目录ID
+        if (!fileInfo.containsKey("fileList") || fileInfo.getJsonArray("fileList").isEmpty()) {
+            fail(FIRST_REQUEST_URL + " 文件列表为空: " + fileInfo);
+            return;
+        }
+        JsonObject fileList = fileInfo.getJsonArray("fileList").getJsonObject(0);
+        if (fileList.getInteger("fileType") == 2) {
+            promise.complete(fileList.getInteger("folderId").toString());
+            return;
+        }
+        // 提取文件信息
+        extractFileInfo(fileList, fileInfo);
+        getDownURL(resJson);
+    }
+
+    private void getDownURL(JsonObject resJson) {
+        String dataKey = shareLinkInfo.getShareKey();
+        // 文件Id
+        JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
+        String fileId = fileInfo.getString("fileIds");
+        String userId = fileInfo.getString("userId");
+        // 其他参数
+        long nowTs2 = System.currentTimeMillis();
+        String tsEncode2 = AESUtils.encrypt2HexIz(Long.toString(nowTs2));
+        String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
+        String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs2);
+
+        // 检查是否有认证信息
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            // 检查是否为临时认证（临时认证每次都尝试登录）
+            boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+            // 如果是临时认证，或者是后台配置且authFlag为true，则尝试使用认证
+            if (isTempAuth || authFlag) {
+                log.debug("尝试使用认证信息解析, isTempAuth={}, authFlag={}", isTempAuth, authFlag);
+                HttpRequest<Buffer> httpRequest =
+                        webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL_VIP))
+                                .setTemplateParam("fidEncode", fidEncode)
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode2)
+                                .setTemplateParam("auth", auth)
+                                .setTemplateParam("dataKey", dataKey);
+                MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+                if (token == null) {
+                    // 执行登录
+                    login(tsEncode2, auths).onFailure(failRes-> {
+                        log.warn("登录失败: {}", failRes.getMessage());
+                        fail(failRes.getMessage());
+                    }).onSuccess(r-> {
+                        httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                .putHeaders(header);
+                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                    });
+                } else {
+                    // 验证token
+                    webClientSession.postAbs(UriTemplate.of(TOKEN_VERIFY_URL))
+                            .setTemplateParam("uuid", uuid)
+                            .setTemplateParam("ts", tsEncode2)
+                            .putHeaders(header).send().onSuccess(res -> {
+                                // log.info("res: {}",asJson(res));
+                                if (asJson(res).getInteger("code") != 200) {
+                                    login(tsEncode2, auths).onFailure(failRes -> {
+                                        log.warn("重新登录失败: {}", failRes.getMessage());
+                                        fail(failRes.getMessage());
+                                    }).onSuccess(r-> {
+                                        httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                                .putHeaders(header);
+                                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                    });
+                                } else {
+                                    httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                            .putHeaders(header);
+                                    httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                }
+                            }).onFailure(handleFail("Token验证"));
+                }
+            } else {
+                // authFlag 为 false，使用免登录解析
+                log.debug("authFlag=false，使用免登录解析");
+                webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                        .putHeaders(header)
+                        .setTemplateParam("fidEncode", fidEncode)
+                        .setTemplateParam("uuid", uuid)
+                        .setTemplateParam("ts", tsEncode2)
+                        .setTemplateParam("auth", auth)
+                        .setTemplateParam("dataKey", dataKey).send()
+                        .onSuccess(this::down).onFailure(handleFail("请求2"));
+            }
+        } else {
+            // 没有认证信息，使用免登录解析
+            log.debug("无认证信息，使用免登录解析");
+            webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                    .putHeaders(header)
+                    .setTemplateParam("fidEncode", fidEncode)
+                    .setTemplateParam("uuid", uuid)
+                    .setTemplateParam("ts", tsEncode2)
+                    .setTemplateParam("auth", auth)
+                    .setTemplateParam("dataKey", dataKey).send()
+                    .onSuccess(this::down).onFailure(handleFail("请求2"));
+        }
+    }
+
+    private Future<Void> login(String tsEncode2, MultiMap auths) {
+        Promise<Void> promise1 = Promise.promise();
+        webClientSession.postAbs(UriTemplate.of(LOGIN_URL))
+                .setTemplateParam("uuid",uuid)
+                .setTemplateParam("ts", tsEncode2)
+                .putHeaders(header)
+                .sendJsonObject(JsonObject.of("loginName", auths.get("username"), "loginPwd", auths.get("password")))
+                .onSuccess(res2->{
+                    JsonObject json = asJson(res2);
+                    if (json.getInteger("code") == 200) {
+                        token = json.getJsonObject("data").getString("appToken");
+                        header.set("appToken", token);
+                        log.info("登录成功 token: {}", token);
+                        promise1.complete();
+                    } else {
+                        // 检查是否为临时认证
+                        boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+                        if (isTempAuth) {
+                            // 临时认证失败，直接返回错误，不影响后台配置的认证
+                            log.warn("临时认证失败: {}", json.getString("msg"));
+                            promise1.fail("临时认证失败: " + json.getString("msg"));
+                        } else {
+                            // 后台配置的认证失败，设置authFlag并返回失败，让下次请求使用免登陆解析
+                            log.warn("后台配置认证失败: {}, authFlag将设为false，请重新解析", json.getString("msg"));
+                            authFlag = false;
+                            promise1.fail("认证失败: " + json.getString("msg") + ", 请重新解析将使用免登陆模式");
+                        }
+                    }
+                }).onFailure(err -> {
+                    log.error("登录请求异常: {}", err.getMessage());
+                    promise1.fail("登录请求异常: " + err.getMessage());
+                });
+        return promise1.future();
+    }
+
+    /**
+     * 从接口返回数据中提取文件信息
+     */
+    private void extractFileInfo(JsonObject fileList, JsonObject shareInfo) {
+        try {
+            // 文件名
+            String fileName = fileList.getString("fileName");
+            shareLinkInfo.getOtherParam().put("fileName", fileName);
+            
+            // 文件大小 (KB -> Bytes)
+            Long fileSize = fileList.getLong("fileSize", 0L) * 1024;
+            shareLinkInfo.getOtherParam().put("fileSize", fileSize);
+            shareLinkInfo.getOtherParam().put("fileSizeFormat", FileSizeConverter.convertToReadableSize(fileSize));
+            
+            // 文件图标
+            String fileIcon = fileList.getString("fileIcon");
+            if (StringUtils.isNotBlank(fileIcon)) {
+                shareLinkInfo.getOtherParam().put("fileIcon", fileIcon);
+            }
+            
+            // 文件ID
+            Long fileId = fileList.getLong("fileId");
+            if (fileId != null) {
+                shareLinkInfo.getOtherParam().put("fileId", fileId.toString());
+            }
+            
+            // 文件类型 (1=文件, 2=目录)
+            Integer fileType = fileList.getInteger("fileType", 1);
+            shareLinkInfo.getOtherParam().put("fileType", fileType == 1 ? "file" : "folder");
+            
+            // 下载次数
+            Integer downloads = fileList.getInteger("fileDownloads", 0);
+            shareLinkInfo.getOtherParam().put("downloadCount", downloads);
+            
+            // 点赞数
+            Integer likes = fileList.getInteger("fileLikes", 0);
+            shareLinkInfo.getOtherParam().put("likeCount", likes);
+            
+            // 评论数
+            Integer comments = fileList.getInteger("fileComments", 0);
+            shareLinkInfo.getOtherParam().put("commentCount", comments);
+            
+            // 评分
+            Double stars = fileList.getDouble("fileStars", 0.0);
+            shareLinkInfo.getOtherParam().put("stars", stars);
+            
+            // 更新时间
+            String updateTime = fileList.getString("updTime");
+            if (StringUtils.isNotBlank(updateTime)) {
+                shareLinkInfo.getOtherParam().put("updateTime", updateTime);
+            }
+            
+            // 创建时间
+            String createTime = null;
+            
+            // 分享信息
+            if (shareInfo != null) {
+                // 分享ID
+                Integer shareId = shareInfo.getInteger("shareId");
+                if (shareId != null) {
+                    shareLinkInfo.getOtherParam().put("shareId", shareId.toString());
+                }
+                
+                // 上传时间
+                String addTime = shareInfo.getString("addTime");
+                if (StringUtils.isNotBlank(addTime)) {
+                    shareLinkInfo.getOtherParam().put("createTime", addTime);
+                    createTime = addTime;
+                }
+                
+                // 预览次数
+                Integer previewNum = shareInfo.getInteger("previewNum", 0);
+                shareLinkInfo.getOtherParam().put("previewCount", previewNum);
+                
+                // 用户信息
+                JsonObject userMap = shareInfo.getJsonObject("map");
+                if (userMap != null) {
+                    String userName = userMap.getString("userName");
+                    if (StringUtils.isNotBlank(userName)) {
+                        shareLinkInfo.getOtherParam().put("userName", userName);
+                    }
+                    
+                    // VIP信息
+                    Integer isVip = userMap.getInteger("isVip", 0);
+                    shareLinkInfo.getOtherParam().put("isVip", isVip == 1);
+                }
+            }
+            
+            // 创建 FileInfo 对象并存入 otherParam
+            FileInfo fileInfoObj = new FileInfo()
+                    .setPanType(shareLinkInfo.getType())
+                    .setFileName(fileName)
+                    .setFileId(fileList.getLong("fileId") != null ? fileList.getLong("fileId").toString() : null)
+                    .setSize(fileSize)
+                    .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                    .setFileType(fileType == 1 ? "file" : "folder")
+                    .setFileIcon(fileList.getString("fileIcon"))
+                    .setDownloadCount(downloads)
+                    .setCreateTime(createTime)
+                    .setUpdateTime(updateTime);
+            shareLinkInfo.getOtherParam().put("fileInfo", fileInfoObj);
+            
+            log.debug("提取文件信息成功: fileName={}, fileSize={}, downloads={}", 
+                    fileName, fileSize, downloads);
+        } catch (Exception e) {
+            log.warn("提取文件信息失败: {}", e.getMessage());
+        }
+    }
+
+    private void down(HttpResponse<Buffer> res2) {
+        MultiMap headers = res2.headers();
+        if (!headers.contains("Location") || StringUtils.isBlank(headers.get("Location"))) {
+            fail("找不到下载链接可能服务器已被禁止或者配置的认证信息有误");
+            return;
+        }
+        promise.complete(headers.get("Location"));
+    }
+
+    // 目录解析
     @Override
     public Future<List<FileInfo>> parseFileList() {
         Promise<List<FileInfo>> promise = Promise.promise();
@@ -158,11 +468,7 @@ public class IzTool extends PanBase {
             return promise.future();
         }
         parse().onSuccess(id -> {
-            if (id != null && id.matches("^[a-zA-Z0-9]+$")) {
-                parserDir(id, shareId, promise);
-            } else {
-                promise.fail("解析目录ID失败");
-            }
+            parserDir(id, shareId, promise);
         }).onFailure(failRes -> {
             log.error("解析目录失败: {}", failRes.getMessage());
             promise.fail(failRes);
@@ -171,113 +477,160 @@ public class IzTool extends PanBase {
     }
 
     private void parserDir(String id, String shareId, Promise<List<FileInfo>> promise) {
+        if (id != null && (id.startsWith("http://") || id.startsWith("https://"))) {
+            FileInfo fileInfo = new FileInfo();
+            fileInfo.setFileName(id)
+                    .setFileId(id)
+                    .setFileType("file")
+                    .setParserUrl(id)
+                    .setPanType(shareLinkInfo.getType());
+            List<FileInfo> result = new ArrayList<>();
+            result.add(fileInfo);
+            promise.complete(result);
+            return;
+        }
+
+        long nowTs = System.currentTimeMillis();
+        String tsEncode = AESUtils.encrypt2HexIz(Long.toString(nowTs));
+
         log.debug("开始解析目录: {}, shareId: {}, uuid: {}, ts: {}", id, shareId, uuid, tsEncode);
         // 开始解析目录: 164312216, shareId: bPMsbg5K, uuid: 0fmVWTx2Ea4zFwkpd7KXf, ts: 20865d7b7f00828279f437cd1f097860
         // 拿到目录ID
-        client.postAbs(UriTemplate.of(FILE_LIST_URL))
+        webClientSession.postAbs(UriTemplate.of(FILE_LIST_URL))
                 .putHeaders(header)
                 .setTemplateParam("shareId", shareId)
                 .setTemplateParam("uuid", uuid)
                 .setTemplateParam("ts", tsEncode)
                 .setTemplateParam("folderId", id)
                 .send().onSuccess(res -> {
-                    JsonObject jsonObject;
-                    try {
-                        jsonObject = asJson(res);
-                    } catch (Exception e) {
-                        promise.fail(FIRST_REQUEST_URL + " 解析JSON失败: " + res.bodyAsString());
+                    String resBody = asText(res);
+                    // 检查是否包含 cookie 验证
+                    if (resBody.contains("var arg1='")) {
+                        log.debug("目录解析需要 cookie 验证，重新创建 session");
+                        webClientSession = WebClientSession.create(clientNoRedirects);
+                        setCookie(resBody);
+                        // 重新请求目录列表
+                        webClientSession.postAbs(UriTemplate.of(FILE_LIST_URL))
+                                .putHeaders(header)
+                                .setTemplateParam("shareId", shareId)
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode)
+                                .setTemplateParam("folderId", id)
+                                .send().onSuccess(res2 -> {
+                                    processDirResponse(res2, shareId, promise);
+                                }).onFailure(err -> {
+                                    log.error("目录解析重试失败: {}", err.getMessage());
+                                    promise.fail("目录解析失败: " + err.getMessage());
+                                });
                         return;
                     }
-                    // System.out.println(jsonObject.encodePrettily());
-                    JsonArray list = jsonObject.getJsonArray("list");
-                    ArrayList<FileInfo> result = new ArrayList<>();
-                    list.forEach(item->{
-                        JsonObject fileJson = (JsonObject) item;
-                        FileInfo fileInfo = new FileInfo();
-
-                        // 映射已知字段
-                        String fileId = fileJson.getString("fileId");
-                        String userId = fileJson.getString("userId");
-
-                        // 回传用到的参数
-                        //"fidEncode", paramJson.getString("fidEncode"))
-                        //"uuid", paramJson.getString("uuid"))
-                        //"ts", paramJson.getString("ts"))
-                        //"auth", paramJson.getString("auth"))
-                        //"shareId", paramJson.getString("shareId"))
-                        String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
-                        String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs);
-                        JsonObject entries = JsonObject.of(
-                                "fidEncode", fidEncode,
-                                "uuid", uuid,
-                                "ts", tsEncode,
-                                "auth", auth,
-                                "shareId", shareId);
-                        byte[] encode = Base64.getEncoder().encode(entries.encode().getBytes());
-                        String param = new String(encode);
-
-                        if (fileJson.getInteger("fileType") == 2) {
-                            // 如果是目录
-                            fileInfo.setFileName(fileJson.getString("name"))
-                                    .setFileId(fileJson.getString("folderId"))
-                                    .setCreateTime(fileJson.getString("updTime"))
-                                    .setFileType("folder")
-                                    .setSize(0L)
-                                    .setSizeStr("0B")
-                                    .setCreateBy(fileJson.getLong("userId").toString())
-                                    .setDownloadCount(fileJson.getInteger("fileDownloads"))
-                                    .setCreateTime(fileJson.getString("updTime"))
-                                    .setFileIcon(fileJson.getString("fileIcon"))
-                                    .setPanType(shareLinkInfo.getType())
-                                    // 设置目录解析的URL
-                                    .setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s&uuid=%s", getDomainName(),
-                                            shareLinkInfo.getShareUrl(), fileJson.getString("folderId"), uuid));
-                            result.add(fileInfo);
-                            return;
-                        }
-                        long fileSize = fileJson.getLong("fileSize") * 1024;
-                        fileInfo.setFileName(fileJson.getString("fileName"))
-                                .setFileId(fileId)
-                                .setCreateTime(fileJson.getString("createTime"))
-                                .setFileType("file")
-                                .setSize(fileSize)
-                                .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
-                                .setCreateBy(fileJson.getLong("userId").toString())
-                                .setDownloadCount(fileJson.getInteger("fileDownloads"))
-                                .setCreateTime(fileJson.getString("updTime"))
-                                .setFileIcon(fileJson.getString("fileIcon"))
-                                .setPanType(shareLinkInfo.getType())
-                                .setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", getDomainName(),
-                                        shareLinkInfo.getType(), param))
-                                .setPreviewUrl(String.format("%s/v2/viewUrl/%s/%s", getDomainName(),
-                                        shareLinkInfo.getType(), param));
-                        result.add(fileInfo);
-                    });
-                    promise.complete(result);
-                }).onFailure(failRes -> {
-                    log.error("解析目录请求失败: {}", failRes.getMessage());
-                    promise.fail(failRes);
+                    processDirResponse(res, shareId, promise);
+                }).onFailure(err -> {
+                    log.error("目录解析请求失败: {}", err.getMessage());
+                    promise.fail("目录解析失败: " + err.getMessage());
                 });
     }
 
+    /**
+     * 处理目录解析响应
+     */
+    private void processDirResponse(HttpResponse<Buffer> res, String shareId, Promise<List<FileInfo>> promise) {
+        try {
+            JsonObject jsonObject = asJson(res);
+            log.debug("目录解析响应: {}", jsonObject.encodePrettily());
+            
+            if (!jsonObject.containsKey("list")) {
+                log.error("目录解析响应缺少 list 字段: {}", jsonObject);
+                promise.fail("目录解析失败: 响应格式错误");
+                return;
+            }
+            
+            JsonArray list = jsonObject.getJsonArray("list");
+            ArrayList<FileInfo> result = new ArrayList<>();
+            list.forEach(item->{
+                JsonObject fileJson = (JsonObject) item;
+                FileInfo fileInfo = new FileInfo();
+
+                // 映射已知字段
+                String fileId = fileJson.getString("fileId");
+                String userId = fileJson.getString("userId");
+
+                // 其他参数 - 每个文件使用新的时间戳
+                long nowTs2 = System.currentTimeMillis();
+                String tsEncode2 = AESUtils.encrypt2HexIz(Long.toString(nowTs2));
+                String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
+                String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs2);
+
+                // 回传用到的参数
+                JsonObject entries = JsonObject.of(
+                        "fidEncode", fidEncode,
+                        "uuid", uuid,
+                        "ts", tsEncode2,
+                        "auth", auth,
+                        "shareId", shareId);
+                String param = CommonUtils.urlBase64Encode(entries.encode());
+
+                if (fileJson.getInteger("fileType") == 2) {
+                    // 如果是目录
+                    fileInfo.setFileName(fileJson.getString("name"))
+                            .setFileId(fileJson.getString("folderId"))
+                            .setCreateTime(fileJson.getString("updTime"))
+                            .setFileType("folder")
+                            .setSize(0L)
+                            .setSizeStr("0B")
+                            .setCreateBy(fileJson.getLong("userId").toString())
+                            .setDownloadCount(fileJson.getInteger("fileDownloads"))
+                            .setCreateTime(fileJson.getString("updTime"))
+                            .setFileIcon(fileJson.getString("fileIcon"))
+                            .setPanType(shareLinkInfo.getType())
+                            // 设置目录解析的URL
+                            .setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s&uuid=%s", getDomainName(),
+                                    shareLinkInfo.getShareUrl(), fileJson.getString("folderId"), uuid));
+                    result.add(fileInfo);
+                    return;
+                }
+                long fileSize = fileJson.getLong("fileSize") * 1024;
+                fileInfo.setFileName(fileJson.getString("fileName"))
+                        .setFileId(fileId)
+                        .setCreateTime(fileJson.getString("createTime"))
+                        .setFileType("file")
+                        .setSize(fileSize)
+                        .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                        .setCreateBy(fileJson.getLong("userId").toString())
+                        .setDownloadCount(fileJson.getInteger("fileDownloads"))
+                        .setCreateTime(fileJson.getString("updTime"))
+                        .setFileIcon(fileJson.getString("fileIcon"))
+                        .setPanType(shareLinkInfo.getType())
+                        .setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", getDomainName(),
+                                shareLinkInfo.getType(), param))
+                        .setPreviewUrl(String.format("%s/v2/viewUrl/%s/%s", getDomainName(),
+                                shareLinkInfo.getType(), param));
+                result.add(fileInfo);
+            });
+            promise.complete(result);
+        } catch (Exception e) {
+            log.error("处理目录响应异常: {}", e.getMessage(), e);
+            promise.fail("目录解析失败: " + e.getMessage());
+        }
+    }
+
     @Override
     public Future<String> parseById() {
-        // 第二次请求
-        JsonObject paramJson = (JsonObject)shareLinkInfo.getOtherParam().get("paramJson");
-        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+        JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+        // 使用免登录接口
+        webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                .putHeaders(header)
                 .setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
                 .setTemplateParam("uuid", paramJson.getString("uuid"))
                 .setTemplateParam("ts", paramJson.getString("ts"))
                 .setTemplateParam("auth", paramJson.getString("auth"))
-                .setTemplateParam("shareId", paramJson.getString("shareId"))
-                .putHeaders(header).send().onSuccess(res2 -> {
-                    MultiMap headers = res2.headers();
-                    if (!headers.contains("Location")) {
-                        fail(SECOND_REQUEST_URL + " 未找到重定向URL: \n" + res2.headers());
-                        return;
-                    }
-                    promise.complete(headers.get("Location"));
-                }).onFailure(handleFail(SECOND_REQUEST_URL));
+                .setTemplateParam("dataKey", paramJson.getString("shareId"))
+                .send().onSuccess(this::down).onFailure(handleFail("parseById"));
         return promise.future();
     }
+
+    public static void resetToken() {
+        token = null;
+        authFlag = true;
+    }
 }

parser/src/main/java/cn/qaiu/parser/impl/IzToolWithAuth.java

@@ -0,0 +1,658 @@
+package cn.qaiu.parser.impl;
+
+import cn.qaiu.entity.FileInfo;
+import cn.qaiu.entity.ShareLinkInfo;
+import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.AESUtils;
+import cn.qaiu.util.AcwScV2Generator;
+import cn.qaiu.util.CommonUtils;
+import cn.qaiu.util.FileSizeConverter;
+import io.netty.handler.codec.http.cookie.DefaultCookie;
+import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+import io.vertx.core.Promise;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+import io.vertx.ext.web.client.HttpRequest;
+import io.vertx.ext.web.client.HttpResponse;
+import io.vertx.ext.web.client.WebClientSession;
+import io.vertx.uritemplate.UriTemplate;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * 蓝奏云优享 - 需要登录版本（支持大文件）
+ */
+public class IzToolWithAuth extends PanBase {
+
+    private static final String API_URL0 = "https://api.ilanzou.com/";
+    private static final String API_URL_PREFIX = "https://api.ilanzou.com/unproved/";
+
+    private static final String FIRST_REQUEST_URL = API_URL_PREFIX + "recommend/list?devType=6&devModel=Chrome" +
+            "&uuid={uuid}&extra=2&timestamp={ts}&shareId={shareId}&type=0&offset=1&limit=60";
+
+    private static final String LOGIN_URL = API_URL_PREFIX +
+            "login?uuid={uuid}&devType=6&devCode={uuid}&devModel=chrome&devVersion=127&appVersion=&timestamp={ts}&appToken=&extra=2";
+
+    // https://api.ilanzou.com/proved/user/info/map?devType=3&devModel=Chrome&uuid=TInRHH3QzRaMo-Ajl2PkJ&extra=2&timestamp=EC2C6E7F45EB21338A17A7621E0BB437
+    private static final String TOKEN_VERIFY_URL = API_URL0 +
+            "proved/user/info/map?devType=6&devModel=Chrome&uuid={uuid}&extra=2&timestamp={ts}";
+
+    private static final String SECOND_REQUEST_URL = API_URL_PREFIX + "file/redirect?downloadId={fidEncode}&enable=1" +
+            "&devType=6&uuid={uuid}&timestamp={ts}&auth={auth}&shareId={dataKey}";
+
+    private static final String SECOND_REQUEST_URL_VIP = API_URL_PREFIX + "file/redirect?uuid={uuid}&devType=6&devCode={uuid}" +
+            "&devModel=chrome&devVersion=127&appVersion=&timestamp={ts}&appToken={appToken}&enable=1&downloadId={fidEncode}&auth={auth}";
+
+
+    private static final String VIP_REQUEST_URL = API_URL_PREFIX + "/buy/vip/list?devType=6&devModel=Chrome&uuid" +
+            "={uuid}&extra=2&timestamp={ts}";
+
+    private static final String FILE_LIST_URL = API_URL_PREFIX + "/share/list?devType=6&devModel=Chrome&uuid" +
+            "={uuid}&extra=2&timestamp={ts}&shareId={shareId}&folderId" +
+            "={folderId}&offset=1&limit=60";
+
+
+    WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
+
+    private static final MultiMap header;
+
+    static {
+        header = MultiMap.caseInsensitiveMultiMap();
+        header.set("Accept", "application/json, text/plain, */*");
+        header.set("Accept-Encoding", "gzip, deflate");
+        header.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8");
+        header.set("Cache-Control", "no-cache");
+        header.set("Connection", "keep-alive");
+        header.set("Content-Length", "0");
+        header.set("DNT", "1");
+        header.set("Host", "api.ilanzou.com");
+        header.set("Origin", "https://www.ilanzou.com/");
+        header.set("Pragma", "no-cache");
+        header.set("Referer", "https://www.ilanzou.com/");
+        header.set("Sec-Fetch-Dest", "empty");
+        header.set("Sec-Fetch-Mode", "cors");
+        header.set("Sec-Fetch-Site", "cross-site");
+        header.set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
+        header.set("sec-ch-ua", "\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"");
+        header.set("sec-ch-ua-mobile", "?0");
+        header.set("sec-ch-ua-platform", "\"Windows\"");
+    }
+    public IzToolWithAuth(ShareLinkInfo shareLinkInfo) {
+        super(shareLinkInfo);
+    }
+
+    String uuid = UUID.randomUUID().toString().toLowerCase(); // 也可以使用 UUID.randomUUID().toString()
+
+    public static String token = null;
+    public static boolean authFlag = true;
+
+    public Future<String> parse() {
+
+        String shareId = shareLinkInfo.getShareKey(); // String.valueOf(AESUtils.idEncrypt(dataKey));
+        long nowTs = System.currentTimeMillis();
+        String tsEncode = AESUtils.encrypt2HexIz(Long.toString(nowTs));
+
+        // 24.5.12 飞机盘 规则修改 需要固定UUID先请求会员接口, 再请求后续接口
+        webClientSession.postAbs(UriTemplate.of(VIP_REQUEST_URL))
+                .setTemplateParam("uuid", uuid)
+                .setTemplateParam("ts", tsEncode)
+                .send().onSuccess(r0 -> { // 忽略res
+
+                    String url = StringUtils.isBlank(shareLinkInfo.getSharePassword()) ? FIRST_REQUEST_URL
+                            : (FIRST_REQUEST_URL + "&code=" + shareLinkInfo.getSharePassword());
+                    // 第一次请求 获取文件信息
+                    // POST https://api.feijipan.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
+                    webClientSession.postAbs(UriTemplate.of(url))
+                            .putHeaders(header)
+                            .setTemplateParam("shareId", shareId)
+                            .setTemplateParam("uuid", uuid)
+                            .setTemplateParam("ts", tsEncode)
+                            .send().onSuccess(res -> {
+                                String resBody = asText(res);
+                                // 检查是否包含 cookie 验证
+                                if (resBody.contains("var arg1='")) {
+                                    webClientSession = WebClientSession.create(clientNoRedirects);
+                                    setCookie(resBody);
+                                    // 重新请求
+                                    webClientSession.postAbs(UriTemplate.of(url))
+                                            .putHeaders(header)
+                                            .setTemplateParam("shareId", shareId)
+                                            .setTemplateParam("uuid", uuid)
+                                            .setTemplateParam("ts", tsEncode)
+                                            .send().onSuccess(res2 -> {
+                                                processFirstResponse(res2);
+                                            }).onFailure(handleFail("请求1-重试"));
+                                    return;
+                                }
+                                processFirstResponse(res);
+                            }).onFailure(handleFail("请求1"));
+
+                }).onFailure(handleFail("请求1"));
+
+        return promise.future();
+    }
+
+    /**
+     * 设置 cookie
+     */
+    private void setCookie(String html) {
+        int beginIndex = html.indexOf("arg1='") + 6;
+        String arg1 = html.substring(beginIndex, html.indexOf("';", beginIndex));
+        String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
+        // 创建一个 Cookie 并放入 CookieStore
+        DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
+        nettyCookie.setDomain(".ilanzou.com"); // 设置域名
+        nettyCookie.setPath("/");             // 设置路径
+        nettyCookie.setSecure(false);
+        nettyCookie.setHttpOnly(false);
+        webClientSession.cookieStore().put(nettyCookie);
+    }
+
+    /**
+     * 处理第一次请求的响应
+     */
+    private void processFirstResponse(HttpResponse<Buffer> res) {
+        JsonObject resJson = asJson(res);
+        if (resJson.getInteger("code") != 200) {
+            fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
+            return;
+        }
+        if (!resJson.containsKey("list") || resJson.getJsonArray("list").isEmpty()) {
+            fail(FIRST_REQUEST_URL + " 解析文件列表为空: " + resJson);
+            return;
+        }
+        // 文件Id
+        JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
+        // 如果是目录返回目录ID
+        if (!fileInfo.containsKey("fileList") || fileInfo.getJsonArray("fileList").isEmpty()) {
+            fail(FIRST_REQUEST_URL + " 文件列表为空: " + fileInfo);
+            return;
+        }
+        JsonObject fileList = fileInfo.getJsonArray("fileList").getJsonObject(0);
+        if (fileList.getInteger("fileType") == 2) {
+            promise.complete(fileList.getInteger("folderId").toString());
+            return;
+        }
+        // 提取文件信息
+        extractFileInfo(fileList, fileInfo);
+        getDownURL(resJson);
+    }
+
+    private void getDownURL(JsonObject resJson) {
+        String dataKey = shareLinkInfo.getShareKey();
+        // 文件Id
+        JsonObject fileInfo = resJson.getJsonArray("list").getJsonObject(0);
+        String fileId = fileInfo.getString("fileIds");
+        String userId = fileInfo.getString("userId");
+        // 其他参数
+        long nowTs2 = System.currentTimeMillis();
+        String tsEncode2 = AESUtils.encrypt2HexIz(Long.toString(nowTs2));
+        String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
+        String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs2);
+
+        // 检查是否有认证信息
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            // 检查是否为临时认证（临时认证每次都尝试登录）
+            boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+            // 如果是临时认证，或者是后台配置且authFlag为true，则尝试使用认证
+            if (isTempAuth || authFlag) {
+                log.debug("尝试使用认证信息解析, isTempAuth={}, authFlag={}", isTempAuth, authFlag);
+                HttpRequest<Buffer> httpRequest =
+                        webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL_VIP))
+                                .setTemplateParam("fidEncode", fidEncode)
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode2)
+                                .setTemplateParam("auth", auth)
+                                .setTemplateParam("dataKey", dataKey);
+                MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+                if (token == null) {
+                    // 执行登录
+                    login(tsEncode2, auths).onFailure(failRes-> {
+                        log.warn("登录失败: {}", failRes.getMessage());
+                        fail(failRes.getMessage());
+                    }).onSuccess(r-> {
+                        httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                .putHeaders(header);
+                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                    });
+                } else {
+                    // 验证token
+                    webClientSession.postAbs(UriTemplate.of(TOKEN_VERIFY_URL))
+                            .setTemplateParam("uuid", uuid)
+                            .setTemplateParam("ts", tsEncode2)
+                            .putHeaders(header).send().onSuccess(res -> {
+                                // log.info("res: {}",asJson(res));
+                                if (asJson(res).getInteger("code") != 200) {
+                                    login(tsEncode2, auths).onFailure(failRes -> {
+                                        log.warn("重新登录失败: {}", failRes.getMessage());
+                                        fail(failRes.getMessage());
+                                    }).onSuccess(r-> {
+                                        httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                                .putHeaders(header);
+                                        httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                    });
+                                } else {
+                                    httpRequest.setTemplateParam("appToken", header.get("appToken"))
+                                            .putHeaders(header);
+                                    httpRequest.send().onSuccess(this::down).onFailure(handleFail("请求2"));
+                                }
+                            }).onFailure(handleFail("Token验证"));
+                }
+            } else {
+                // authFlag 为 false，使用免登录解析
+                log.debug("authFlag=false，使用免登录解析");
+                webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                        .putHeaders(header)
+                        .setTemplateParam("fidEncode", fidEncode)
+                        .setTemplateParam("uuid", uuid)
+                        .setTemplateParam("ts", tsEncode2)
+                        .setTemplateParam("auth", auth)
+                        .setTemplateParam("dataKey", dataKey).send()
+                        .onSuccess(this::down).onFailure(handleFail("请求2"));
+            }
+        } else {
+            // 没有认证信息，使用免登录解析
+            log.debug("无认证信息，使用免登录解析");
+            webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                    .putHeaders(header)
+                    .setTemplateParam("fidEncode", fidEncode)
+                    .setTemplateParam("uuid", uuid)
+                    .setTemplateParam("ts", tsEncode2)
+                    .setTemplateParam("auth", auth)
+                    .setTemplateParam("dataKey", dataKey).send()
+                    .onSuccess(this::down).onFailure(handleFail("请求2"));
+        }
+    }
+
+    private Future<Void> login(String tsEncode2, MultiMap auths) {
+        Promise<Void> promise1 = Promise.promise();
+        webClientSession.postAbs(UriTemplate.of(LOGIN_URL))
+                .setTemplateParam("uuid",uuid)
+                .setTemplateParam("ts", tsEncode2)
+                .putHeaders(header)
+                .sendJsonObject(JsonObject.of("loginName", auths.get("username"), "loginPwd", auths.get("password")))
+                .onSuccess(res2->{
+                    JsonObject json = asJson(res2);
+                    if (json.getInteger("code") == 200) {
+                        token = json.getJsonObject("data").getString("appToken");
+                        header.set("appToken", token);
+                        log.info("登录成功 token: {}", token);
+                        promise1.complete();
+                    } else {
+                        // 检查是否为临时认证
+                        boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+                        if (isTempAuth) {
+                            // 临时认证失败，直接返回错误，不影响后台配置的认证
+                            log.warn("临时认证失败: {}", json.getString("msg"));
+                            promise1.fail("临时认证失败: " + json.getString("msg"));
+                        } else {
+                            // 后台配置的认证失败，设置authFlag并返回失败，让下次请求使用免登陆解析
+                            log.warn("后台配置认证失败: {}, authFlag将设为false，请重新解析", json.getString("msg"));
+                            authFlag = false;
+                            promise1.fail("认证失败: " + json.getString("msg") + ", 请重新解析将使用免登陆模式");
+                        }
+                    }
+                }).onFailure(err -> {
+                    log.error("登录请求异常: {}", err.getMessage());
+                    promise1.fail("登录请求异常: " + err.getMessage());
+                });
+        return promise1.future();
+    }
+
+    /**
+     * 从接口返回数据中提取文件信息
+     */
+    private void extractFileInfo(JsonObject fileList, JsonObject shareInfo) {
+        try {
+            // 文件名
+            String fileName = fileList.getString("fileName");
+            shareLinkInfo.getOtherParam().put("fileName", fileName);
+            
+            // 文件大小 (KB -> Bytes)
+            Long fileSize = fileList.getLong("fileSize", 0L) * 1024;
+            shareLinkInfo.getOtherParam().put("fileSize", fileSize);
+            shareLinkInfo.getOtherParam().put("fileSizeFormat", FileSizeConverter.convertToReadableSize(fileSize));
+            
+            // 文件图标
+            String fileIcon = fileList.getString("fileIcon");
+            if (StringUtils.isNotBlank(fileIcon)) {
+                shareLinkInfo.getOtherParam().put("fileIcon", fileIcon);
+            }
+            
+            // 文件ID
+            Long fileId = fileList.getLong("fileId");
+            if (fileId != null) {
+                shareLinkInfo.getOtherParam().put("fileId", fileId.toString());
+            }
+            
+            // 文件类型 (1=文件, 2=目录)
+            Integer fileType = fileList.getInteger("fileType", 1);
+            shareLinkInfo.getOtherParam().put("fileType", fileType == 1 ? "file" : "folder");
+            
+            // 下载次数
+            Integer downloads = fileList.getInteger("fileDownloads", 0);
+            shareLinkInfo.getOtherParam().put("downloadCount", downloads);
+            
+            // 点赞数
+            Integer likes = fileList.getInteger("fileLikes", 0);
+            shareLinkInfo.getOtherParam().put("likeCount", likes);
+            
+            // 评论数
+            Integer comments = fileList.getInteger("fileComments", 0);
+            shareLinkInfo.getOtherParam().put("commentCount", comments);
+            
+            // 评分
+            Double stars = fileList.getDouble("fileStars", 0.0);
+            shareLinkInfo.getOtherParam().put("stars", stars);
+            
+            // 更新时间
+            String updateTime = fileList.getString("updTime");
+            if (StringUtils.isNotBlank(updateTime)) {
+                shareLinkInfo.getOtherParam().put("updateTime", updateTime);
+            }
+            
+            // 创建时间
+            String createTime = null;
+            
+            // 分享信息
+            if (shareInfo != null) {
+                // 分享ID
+                Integer shareId = shareInfo.getInteger("shareId");
+                if (shareId != null) {
+                    shareLinkInfo.getOtherParam().put("shareId", shareId.toString());
+                }
+                
+                // 上传时间
+                String addTime = shareInfo.getString("addTime");
+                if (StringUtils.isNotBlank(addTime)) {
+                    shareLinkInfo.getOtherParam().put("createTime", addTime);
+                    createTime = addTime;
+                }
+                
+                // 预览次数
+                Integer previewNum = shareInfo.getInteger("previewNum", 0);
+                shareLinkInfo.getOtherParam().put("previewCount", previewNum);
+                
+                // 用户信息
+                JsonObject userMap = shareInfo.getJsonObject("map");
+                if (userMap != null) {
+                    String userName = userMap.getString("userName");
+                    if (StringUtils.isNotBlank(userName)) {
+                        shareLinkInfo.getOtherParam().put("userName", userName);
+                    }
+                    
+                    // VIP信息
+                    Integer isVip = userMap.getInteger("isVip", 0);
+                    shareLinkInfo.getOtherParam().put("isVip", isVip == 1);
+                }
+            }
+            
+            // 创建 FileInfo 对象并存入 otherParam
+            FileInfo fileInfoObj = new FileInfo()
+                    .setPanType(shareLinkInfo.getType())
+                    .setFileName(fileName)
+                    .setFileId(fileList.getLong("fileId") != null ? fileList.getLong("fileId").toString() : null)
+                    .setSize(fileSize)
+                    .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                    .setFileType(fileType == 1 ? "file" : "folder")
+                    .setFileIcon(fileList.getString("fileIcon"))
+                    .setDownloadCount(downloads)
+                    .setCreateTime(createTime)
+                    .setUpdateTime(updateTime);
+            shareLinkInfo.getOtherParam().put("fileInfo", fileInfoObj);
+            
+            log.debug("提取文件信息成功: fileName={}, fileSize={}, downloads={}", 
+                    fileName, fileSize, downloads);
+        } catch (Exception e) {
+            log.warn("提取文件信息失败: {}", e.getMessage());
+        }
+    }
+
+    private void down(HttpResponse<Buffer> res2) {
+        MultiMap headers = res2.headers();
+        if (!headers.contains("Location") || StringUtils.isBlank(headers.get("Location"))) {
+            fail("找不到下载链接可能服务器已被禁止或者配置的认证信息有误");
+            return;
+        }
+        promise.complete(headers.get("Location"));
+    }
+
+    // 目录解析
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        Promise<List<FileInfo>> promise = Promise.promise();
+
+        String shareId = shareLinkInfo.getShareKey(); // String.valueOf(AESUtils.idEncrypt(dataKey));
+
+        // 如果参数里的目录ID不为空，则直接解析目录
+        String dirId = (String) shareLinkInfo.getOtherParam().get("dirId");
+        if (dirId != null && !dirId.isEmpty()) {
+            uuid = shareLinkInfo.getOtherParam().get("uuid").toString();
+            parserDir(dirId, shareId, promise);
+            return promise.future();
+        }
+        parse().onSuccess(id -> {
+            parserDir(id, shareId, promise);
+        }).onFailure(failRes -> {
+            log.error("解析目录失败: {}", failRes.getMessage());
+            promise.fail(failRes);
+        });
+        return promise.future();
+    }
+
+    private void parserDir(String id, String shareId, Promise<List<FileInfo>> promise) {
+        if (id != null && (id.startsWith("http://") || id.startsWith("https://"))) {
+            FileInfo fileInfo = new FileInfo();
+            fileInfo.setFileName(id)
+                    .setFileId(id)
+                    .setFileType("file")
+                    .setParserUrl(id)
+                    .setPanType(shareLinkInfo.getType());
+            List<FileInfo> result = new ArrayList<>();
+            result.add(fileInfo);
+            promise.complete(result);
+            return;
+        }
+
+        long nowTs = System.currentTimeMillis();
+        String tsEncode = AESUtils.encrypt2HexIz(Long.toString(nowTs));
+
+        log.debug("开始解析目录: {}, shareId: {}, uuid: {}, ts: {}", id, shareId, uuid, tsEncode);
+        
+        // 检查是否需要登录（有认证信息且需要使用认证）
+        if (shareLinkInfo.getOtherParam().containsKey("auths")) {
+            boolean isTempAuth = shareLinkInfo.getOtherParam().containsKey("__TEMP_AUTH_ADDED");
+            log.debug("目录解析检查认证: isTempAuth={}, authFlag={}, token={}", isTempAuth, authFlag, token != null ? "已有" : "null");
+            
+            if ((isTempAuth || authFlag) && token == null) {
+                MultiMap auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+                log.info("目录解析需要登录，开始执行登录...");
+                // 先登录获取 token
+                login(tsEncode, auths)
+                        .onFailure(err -> {
+                            log.warn("目录解析登录失败，使用免登录模式: {}", err.getMessage());
+                            // 登录失败，继续使用免登录
+                            requestDirList(id, shareId, tsEncode, promise);
+                        })
+                        .onSuccess(r -> {
+                            log.info("目录解析登录成功，token={}, 使用 VIP 模式", token != null ? token.substring(0, 10) + "..." : "null");
+                            requestDirList(id, shareId, tsEncode, promise);
+                        });
+                return;
+            } else if (token != null) {
+                log.debug("目录解析已有 token，直接使用 VIP 模式");
+            } else {
+                log.debug("目录解析: authFlag=false 或为临时认证但已失败，使用免登录模式");
+            }
+        } else {
+            log.debug("目录解析无认证信息，使用免登录模式");
+        }
+        
+        // 无需登录或已登录，直接请求
+        requestDirList(id, shareId, tsEncode, promise);
+    }
+
+    /**
+     * 请求目录列表
+     */
+    private void requestDirList(String id, String shareId, String tsEncode, Promise<List<FileInfo>> promise) {
+        webClientSession.postAbs(UriTemplate.of(FILE_LIST_URL))
+                .putHeaders(header)
+                .setTemplateParam("shareId", shareId)
+                .setTemplateParam("uuid", uuid)
+                .setTemplateParam("ts", tsEncode)
+                .setTemplateParam("folderId", id)
+                .send().onSuccess(res -> {
+                    String resBody = asText(res);
+                    // 检查是否包含 cookie 验证
+                    if (resBody.contains("var arg1='")) {
+                        log.debug("目录解析需要 cookie 验证，重新创建 session");
+                        webClientSession = WebClientSession.create(clientNoRedirects);
+                        setCookie(resBody);
+                        // 重新请求目录列表
+                        webClientSession.postAbs(UriTemplate.of(FILE_LIST_URL))
+                                .putHeaders(header)
+                                .setTemplateParam("shareId", shareId)
+                                .setTemplateParam("uuid", uuid)
+                                .setTemplateParam("ts", tsEncode)
+                                .setTemplateParam("folderId", id)
+                                .send().onSuccess(res2 -> {
+                                    processDirResponse(res2, shareId, promise);
+                                }).onFailure(err -> {
+                                    log.error("目录解析重试失败: {}", err.getMessage());
+                                    promise.fail("目录解析失败: " + err.getMessage());
+                                });
+                        return;
+                    }
+                    processDirResponse(res, shareId, promise);
+                }).onFailure(err -> {
+                    log.error("目录解析请求失败: {}", err.getMessage());
+                    promise.fail("目录解析失败: " + err.getMessage());
+                });
+    }
+
+    /**
+     * 处理目录解析响应
+     */
+    private void processDirResponse(HttpResponse<Buffer> res, String shareId, Promise<List<FileInfo>> promise) {
+        try {
+            JsonObject jsonObject = asJson(res);
+            log.debug("目录解析响应: {}", jsonObject.encodePrettily());
+            
+            if (!jsonObject.containsKey("list")) {
+                log.error("目录解析响应缺少 list 字段: {}", jsonObject);
+                promise.fail("目录解析失败: 响应格式错误");
+                return;
+            }
+            
+            JsonArray list = jsonObject.getJsonArray("list");
+            ArrayList<FileInfo> result = new ArrayList<>();
+            list.forEach(item->{
+                JsonObject fileJson = (JsonObject) item;
+                FileInfo fileInfo = new FileInfo();
+
+                // 映射已知字段
+                String fileId = fileJson.getString("fileId");
+                String userId = fileJson.getString("userId");
+
+                // 其他参数 - 每个文件使用新的时间戳
+                long nowTs2 = System.currentTimeMillis();
+                String tsEncode2 = AESUtils.encrypt2HexIz(Long.toString(nowTs2));
+                String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
+                String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs2);
+
+                // 回传用到的参数（包含 token）
+                JsonObject entries = JsonObject.of(
+                        "fidEncode", fidEncode,
+                        "uuid", uuid,
+                        "ts", tsEncode2,
+                        "auth", auth,
+                        "shareId", shareId,
+                        "appToken", token != null ? token : "");
+                String param = CommonUtils.urlBase64Encode(entries.encode());
+
+                if (fileJson.getInteger("fileType") == 2) {
+                    // 如果是目录
+                    fileInfo.setFileName(fileJson.getString("name"))
+                            .setFileId(fileJson.getString("folderId"))
+                            .setCreateTime(fileJson.getString("updTime"))
+                            .setFileType("folder")
+                            .setSize(0L)
+                            .setSizeStr("0B")
+                            .setCreateBy(fileJson.getLong("userId").toString())
+                            .setDownloadCount(fileJson.getInteger("fileDownloads"))
+                            .setCreateTime(fileJson.getString("updTime"))
+                            .setFileIcon(fileJson.getString("fileIcon"))
+                            .setPanType(shareLinkInfo.getType())
+                            // 设置目录解析的URL
+                            .setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s&uuid=%s", getDomainName(),
+                                    shareLinkInfo.getShareUrl(), fileJson.getString("folderId"), uuid));
+                    result.add(fileInfo);
+                    return;
+                }
+                long fileSize = fileJson.getLong("fileSize") * 1024;
+                fileInfo.setFileName(fileJson.getString("fileName"))
+                        .setFileId(fileId)
+                        .setCreateTime(fileJson.getString("createTime"))
+                        .setFileType("file")
+                        .setSize(fileSize)
+                        .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                        .setCreateBy(fileJson.getLong("userId").toString())
+                        .setDownloadCount(fileJson.getInteger("fileDownloads"))
+                        .setCreateTime(fileJson.getString("updTime"))
+                        .setFileIcon(fileJson.getString("fileIcon"))
+                        .setPanType(shareLinkInfo.getType())
+                        .setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", getDomainName(),
+                                shareLinkInfo.getType(), param))
+                        .setPreviewUrl(String.format("%s/v2/viewUrl/%s/%s", getDomainName(),
+                                shareLinkInfo.getType(), param));
+                result.add(fileInfo);
+            });
+            promise.complete(result);
+        } catch (Exception e) {
+            log.error("处理目录响应异常: {}", e.getMessage(), e);
+            promise.fail("目录解析失败: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public Future<String> parseById() {
+        JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+        String appToken = paramJson.getString("appToken", "");
+        
+        // 如果有 token，使用 VIP 接口
+        if (StringUtils.isNotBlank(appToken)) {
+            log.debug("parseById 使用 VIP 接口, appToken={}", appToken.substring(0, Math.min(10, appToken.length())) + "...");
+            webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL_VIP))
+                    .putHeaders(header)
+                    .setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
+                    .setTemplateParam("uuid", paramJson.getString("uuid"))
+                    .setTemplateParam("ts", paramJson.getString("ts"))
+                    .setTemplateParam("auth", paramJson.getString("auth"))
+                    .setTemplateParam("appToken", appToken)
+                    .send().onSuccess(this::down).onFailure(handleFail("parseById-VIP"));
+        } else {
+            // 无 token，使用免登录接口
+            log.debug("parseById 使用免登录接口");
+            webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                    .putHeaders(header)
+                    .setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
+                    .setTemplateParam("uuid", paramJson.getString("uuid"))
+                    .setTemplateParam("ts", paramJson.getString("ts"))
+                    .setTemplateParam("auth", paramJson.getString("auth"))
+                    .setTemplateParam("dataKey", paramJson.getString("shareId"))
+                    .send().onSuccess(this::down).onFailure(handleFail("parseById"));
+        }
+        return promise.future();
+    }
+
+    public static void resetToken() {
+        token = null;
+        authFlag = true;
+    }
+}

parser/src/main/java/cn/qaiu/parser/impl/LeTool.java

@@ -1,30 +1,72 @@
 package cn.qaiu.parser.impl;
 
+import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo; 
 import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.FileSizeConverter;
 import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+import io.vertx.core.Promise;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
 
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
 import java.util.UUID;
 
 /**
  * <a href="https://lecloud.lenovo.com/">联想乐云</a>
  */
 public class LeTool extends PanBase {
-    private static final String API_URL_PREFIX = "https://lecloud.lenovo.com/share/api/clouddiskapi/share/public/v1/";
+    private static final String API_URL_PREFIX = "https://lecloud.lenovo.com/mshare/api/clouddiskapi/share/public/v1/";
+    private static final String DEFAULT_FILE_TYPE = "file";
+    private static final int FILE_TYPE_DIRECTORY = 0; // 目录类型
+
+    private static final MultiMap HEADERS;
+
+    static {
+        HEADERS = MultiMap.caseInsensitiveMultiMap();
+        HEADERS.set("Accept", "application/json, text/plain, */*");
+        HEADERS.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6");
+        HEADERS.set("Cache-Control", "no-cache");
+        HEADERS.set("Connection", "keep-alive");
+        HEADERS.set("Content-Type", "application/json");
+        HEADERS.set("DNT", "1");
+        HEADERS.set("Origin", "https://lecloud.lenovo.com");
+        HEADERS.set("Pragma", "no-cache");
+        HEADERS.set("Sec-Fetch-Dest", "empty");
+        HEADERS.set("Sec-Fetch-Mode", "cors");
+        HEADERS.set("Sec-Fetch-Site", "same-origin");
+        HEADERS.set("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1 Edg/143.0.0.0");
+    }
 
     public LeTool(ShareLinkInfo shareLinkInfo) {
         super(shareLinkInfo);
     }
 
+    /**
+     * 获取干净的 shareId（去掉可能的查询参数）
+     * URL 如 https://lecloud.lenovo.com/share/5eoN3RA5PLhQcH4zE?path=... 会导致 shareKey 包含查询参数
+     */
+    private String getCleanShareId() {
+        String shareKey = shareLinkInfo.getShareKey();
+        if (shareKey != null && shareKey.contains("?")) {
+            return shareKey.split("\\?")[0];
+        }
+        return shareKey;
+    }
+
     public Future<String> parse() {
-        final String dataKey = shareLinkInfo.getShareKey();
+        final String dataKey = getCleanShareId();
         final String pwd = shareLinkInfo.getSharePassword();
         // {"shareId":"xxx","password":"xxx","directoryId":"-1"}
         String apiUrl1 = API_URL_PREFIX + "shareInfo";
         client.postAbs(apiUrl1)
-                .sendJsonObject(JsonObject.of("shareId", dataKey, "password", pwd, "directoryId", -1))
+            .putHeaders(HEADERS)
+            .sendJsonObject(JsonObject.of("shareId", dataKey, "password", pwd, "directoryId", "-1"))
                 .onSuccess(res -> {
                     JsonObject resJson = asJson(res);
                     if (resJson.containsKey("result")) {
@@ -44,7 +86,19 @@ public class LeTool extends PanBase {
                             }
                             JsonObject fileInfoJson = files.getJsonObject(0);
                             if (fileInfoJson != null) {
-                                // TODO 文件大小fileSize和文件名fileName
+                                // Extract and populate FileInfo
+                                FileInfo fileInfo = createFileInfo(fileInfoJson);
+                                shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
+                                
+                                // 判断是否为目录
+                                Integer fileType = fileInfoJson.getInteger("fileType");
+                                if (fileType != null && fileType == FILE_TYPE_DIRECTORY) {
+                                    // 如果是目录，返回目录ID
+                                    String fileId = fileInfoJson.getString("fileId");
+                                    promise.complete(fileId);
+                                    return;
+                                }
+                                
                                 String fileId = fileInfoJson.getString("fileId");
                                 // 根据文件ID获取跳转链接
                                 getDownURL(dataKey, fileId);
@@ -59,13 +113,205 @@ public class LeTool extends PanBase {
         return promise.future();
     }
 
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        Promise<List<FileInfo>> listPromise = Promise.promise();
+
+        String dataKey = getCleanShareId();
+        
+        // 如果参数里的目录ID不为空，则直接解析目录
+        String dirId = (String) shareLinkInfo.getOtherParam().get("dirId");
+        if (dirId == null || dirId.isEmpty()) {
+            // 如果没有指定目录ID，使用根目录ID "-1"
+            dirId = "-1";
+        }
+        
+        // 直接请求shareInfo接口解析目录
+        parseDirectory(dirId, dataKey, listPromise);
+        return listPromise.future();
+    }
+
+    /**
+     * 解析目录下的文件列表
+     */
+    private void parseDirectory(String directoryId, String shareId, Promise<List<FileInfo>> promise) {
+        String pwd = shareLinkInfo.getSharePassword();
+        if (pwd == null) {
+            pwd = "";
+        }
+        String apiUrl = API_URL_PREFIX + "shareInfo";
+        
+        JsonObject requestBody = JsonObject.of("shareId", shareId, "password", pwd, "directoryId", directoryId);
+        log.info("解析目录请求: url={}, body={}", apiUrl, requestBody.encode());
+        
+        client.postAbs(apiUrl)
+            .putHeaders(HEADERS)
+            .sendJsonObject(requestBody)
+                .onSuccess(res -> {
+                    JsonObject resJson = asJson(res);
+                    
+                    if (!resJson.containsKey("result") || !resJson.getBoolean("result")) {
+                        promise.fail("解析目录失败: " + resJson.encode());
+                        return;
+                    }
+                    
+                    JsonObject dataJson = resJson.getJsonObject("data");
+                    if (!dataJson.getBoolean("passwordVerified")) {
+                        promise.fail("密码验证失败");
+                        return;
+                    }
+                    
+                    JsonArray files = dataJson.getJsonArray("files");
+                    if (files == null || files.isEmpty()) {
+                        promise.complete(new ArrayList<>());
+                        return;
+                    }
+                    
+                    List<FileInfo> fileList = new ArrayList<>();
+                    for (int i = 0; i < files.size(); i++) {
+                        JsonObject fileJson = files.getJsonObject(i);
+                        FileInfo fileInfo = createFileInfoForList(fileJson, shareId);
+                        fileList.add(fileInfo);
+                    }
+                    
+                    promise.complete(fileList);
+                })
+                .onFailure(err -> {
+                    log.error("解析目录请求失败: {}", err.getMessage());
+                    promise.fail(err);
+                });
+    }
+
+    /**
+     * 为文件列表创建 FileInfo 对象
+     */
+    private FileInfo createFileInfoForList(JsonObject fileJson, String shareId) {
+        FileInfo fileInfo = new FileInfo();
+        
+        try {
+            String fileId = fileJson.getString("fileId");
+            String fileName = fileJson.getString("fileName");
+            Long fileSize = fileJson.getLong("fileSize");
+            Integer fileType = fileJson.getInteger("fileType");
+            
+            fileInfo.setFileId(fileId);
+            fileInfo.setFileName(fileName);
+            fileInfo.setPanType(shareLinkInfo.getType());
+            
+            // 判断是否为目录
+            if (fileType != null && fileType == FILE_TYPE_DIRECTORY) {
+                // 目录类型
+                fileInfo.setFileType("folder");
+                fileInfo.setSize(0L);
+                fileInfo.setSizeStr("0B");
+                // 设置目录解析的URL - fileId 需要进行 URL 编码以保持特殊字符的编码状态
+                try {
+                    String encodedFileId = URLEncoder.encode(fileId, "UTF-8");
+                    fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s", 
+                            getDomainName(), 
+                            shareLinkInfo.getShareUrl(), 
+                            encodedFileId));
+                } catch (UnsupportedEncodingException e) {
+                    log.error("URL编码失败: {}", e.getMessage());
+                    // 降级方案：直接使用原始 fileId
+                    fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s", 
+                            getDomainName(), 
+                            shareLinkInfo.getShareUrl(), 
+                            fileId));
+                }
+            } else {
+                // 文件类型
+                fileInfo.setFileType(fileType != null ? String.valueOf(fileType) : DEFAULT_FILE_TYPE);
+                fileInfo.setSize(fileSize);
+                fileInfo.setSizeStr(FileSizeConverter.convertToReadableSize(fileSize));
+                
+                // 创建参数JSON并编码为Base64
+                JsonObject paramJson = JsonObject.of(
+                        "shareId", shareId,
+                        "fileId", fileId
+                );
+                String paramBase64 = Base64.getEncoder().encodeToString(paramJson.encode().getBytes());
+                
+                // 设置解析URL和预览URL
+                fileInfo.setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", 
+                        getDomainName(), 
+                        shareLinkInfo.getType(), 
+                        paramBase64))
+                        .setPreviewUrl(String.format("%s/v2/viewUrl/%s/%s", 
+                                getDomainName(),
+                                shareLinkInfo.getType(), 
+                                paramBase64));
+            }
+            
+        } catch (Exception e) {
+            log.warn("创建文件信息失败: {}", e.getMessage());
+        }
+        
+        return fileInfo;
+    }
+
+    @Override
+    public Future<String> parseById() {
+        Promise<String> parsePromise = Promise.promise();
+        
+        try {
+            // 从参数中获取解析所需的信息
+            JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+            String shareId = paramJson.getString("shareId");
+            String fileId = paramJson.getString("fileId");
+            
+            // 调用获取下载链接
+            getDownURLForById(shareId, fileId, parsePromise);
+            
+        } catch (Exception e) {
+            parsePromise.fail("解析参数失败: " + e.getMessage());
+        }
+        
+        return parsePromise.future();
+    }
+
+    /**
+     * 根据文件ID获取下载URL (用于 parseById)
+     */
+    private void getDownURLForById(String shareId, String fileId, Promise<String> promise) {
+        String uuid = UUID.randomUUID().toString();
+        JsonArray fileIds = JsonArray.of(fileId);
+        String apiUrl = API_URL_PREFIX + "packageDownloadWithFileIds";
+        
+        client.postAbs(apiUrl)
+            .putHeaders(HEADERS)
+            .sendJsonObject(JsonObject.of("fileIds", fileIds, "shareId", shareId, "browserId", uuid))
+                .onSuccess(res -> {
+                    JsonObject resJson = asJson(res);
+                    if (resJson.containsKey("result")) {
+                        if (resJson.getBoolean("result")) {
+                            JsonObject dataJson = resJson.getJsonObject("data");
+                            String downloadUrl = dataJson.getString("downloadUrl");
+                            if (downloadUrl == null) {
+                                promise.fail("Result JSON数据异常: downloadUrl不存在");
+                                return;
+                            }
+                            // 获取重定向链接
+                            clientNoRedirects.getAbs(downloadUrl).send()
+                                    .onSuccess(res2 -> promise.complete(res2.headers().get("Location")))
+                                    .onFailure(err -> promise.fail(err));
+                        } else {
+                            promise.fail(resJson.getString("errcode") + ": " + resJson.getString("errmsg"));
+                        }
+                    } else {
+                        promise.fail("Result JSON数据异常: result字段不存在");
+                    }
+                }).onFailure(err -> promise.fail(err));
+    }
+
     private void getDownURL(String key, String fileId) {
         String uuid = UUID.randomUUID().toString();
         JsonArray fileIds = JsonArray.of(fileId);
         String apiUrl2 = API_URL_PREFIX + "packageDownloadWithFileIds";
         // {"fileIds":[123],"shareId":"xxx","browserId":"uuid"}
         client.postAbs(apiUrl2)
-                .sendJsonObject(JsonObject.of("fileIds", fileIds, "shareId", key, "browserId", uuid))
+            .putHeaders(HEADERS)
+            .sendJsonObject(JsonObject.of("fileIds", fileIds, "shareId", key, "browserId", uuid))
                 .onSuccess(res -> {
                     JsonObject resJson = asJson(res);
                     if (resJson.containsKey("result")) {
@@ -89,4 +335,51 @@ public class LeTool extends PanBase {
                     }
                 }).onFailure(handleFail(apiUrl2));
     }
+
+    /**
+     * Create FileInfo object from JSON response
+     * Uses exact field names from the API response without fallback checks
+     */
+    private FileInfo createFileInfo(JsonObject fileInfoJson) {
+        FileInfo fileInfo = new FileInfo();
+        
+        try {
+            // Set fileId
+            String fileId = fileInfoJson.getString("fileId");
+            if (fileId != null) {
+                fileInfo.setFileId(fileId);
+            }
+            
+            // Set fileName
+            String fileName = fileInfoJson.getString("fileName");
+            if (fileName != null) {
+                fileInfo.setFileName(fileName);
+            }
+            
+            // Set file size
+            Long fileSize = fileInfoJson.getLong("fileSize");
+            if (fileSize != null) {
+                fileInfo.setSize(fileSize);
+                // Convert to readable size string
+                fileInfo.setSizeStr(FileSizeConverter.convertToReadableSize(fileSize));
+            }
+            
+            // Set fileType (API returns it as an integer)
+            Integer fileTypeInt = fileInfoJson.getInteger("fileType");
+            if (fileTypeInt != null) {
+                fileInfo.setFileType(String.valueOf(fileTypeInt));
+            } else {
+                // Default to generic file type if not available
+                fileInfo.setFileType(DEFAULT_FILE_TYPE);
+            }
+            
+            // Set panType
+            fileInfo.setPanType(shareLinkInfo.getType());
+            
+        } catch (Exception e) {
+            log.warn("Error extracting file info from JSON: {}", e.getMessage());
+        }
+        
+        return fileInfo;
+    }
 }

parser/src/main/java/cn/qaiu/parser/impl/LzTool.java

@@ -11,14 +11,12 @@ import io.vertx.core.Promise;
 import io.vertx.core.json.JsonObject;
 import io.vertx.ext.web.client.WebClient;
 import io.vertx.ext.web.client.WebClientSession;
-import org.apache.commons.lang3.RegExUtils;
 import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
 
 import javax.script.ScriptException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.TreeMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -29,13 +27,14 @@ import java.util.regex.Pattern;
  */
 public class LzTool extends PanBase {
 
-    public static final String SHARE_URL_PREFIX = "https://wwwwp.lanzoup.com";
+    WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
+
+    public static final String SHARE_URL_PREFIX = "https://w1.lanzn.com/";
     MultiMap headers0 = HeaderUtils.parseHeaders("""
         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-Encoding: gzip, deflate
         Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
         Cache-Control: max-age=0
-        Cookie: codelen=1; pc_ad1=1
         DNT: 1
         Priority: u=0, i
         Sec-CH-UA: "Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"
@@ -63,53 +62,134 @@ public class LzTool extends PanBase {
                 .putHeaders(headers0)
                 .send().onSuccess(res -> {
                     String html = asText(res);
-                    try {
-                        setFileInfo(html, shareLinkInfo);
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                    }
-                    // 匹配iframe
-                    Pattern compile = Pattern.compile("src=\"(/fn\\?[a-zA-Z\\d_+/=]{16,})\"");
-                    Matcher matcher = compile.matcher(html);
-                    // 没有Iframe说明是加密分享, 匹配sign通过密码请求下载页面
-                    if (!matcher.find()) {
-                        try {
-                            String jsText = getJsByPwd(pwd, html, "document.getElementById('rpt')");
-                            ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, "down_p");
-                            getDownURL(sUrl, client, scriptObjectMirror);
-                        } catch (Exception e) {
-                            fail(e, "js引擎执行失败");
-                        }
-                    } else {
-                        // 没有密码
-                        String iframePath = matcher.group(1);
-                        client.getAbs(SHARE_URL_PREFIX + iframePath).send().onSuccess(res2 -> {
-                            String html2 = res2.bodyAsString();
+                    if (html.contains("var arg1='")) {
+                        webClientSession = WebClientSession.create(clientNoRedirects);
+                        setCookie(html, sUrl);
+                        webClientSession.getAbs(sUrl)
+                                .putHeaders(headers0)
+                                .send().onSuccess(res2 -> {
+                                    String html2 = asText(res2);
+                                    doParser(html2, pwd, sUrl);
+                                });
 
-                            // 去TMD正则
-                            // Matcher matcher2 = Pattern.compile("'sign'\s*:\s*'(\\w+)'").matcher(html2);
-                            String jsText = getJsText(html2);
-                            if (jsText == null) {
-                                fail(SHARE_URL_PREFIX + iframePath + " -> " + sUrl + ": js脚本匹配失败, 可能分享已失效");
-                                return;
-                            }
-                            try {
-                                ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, null);
-                                getDownURL(sUrl, client, scriptObjectMirror);
-                            } catch (ScriptException | NoSuchMethodException e) {
-                                fail(e, "js引擎执行失败");
-                            }
-                        }).onFailure(handleFail(SHARE_URL_PREFIX));
+                    } else {
+                        doParser(html, pwd, sUrl);
                     }
+
                 }).onFailure(handleFail(sUrl));
         return promise.future();
     }
 
+    private void doParser(String html, String pwd, String sUrl) {
+        // 检测是否为目录分享链接 (含 /s/、/b/ 路径段或 b0 开头的路径段)
+        if (sUrl.matches(".*/(s|b)/[^/]+.*") || sUrl.matches(".*/b0[^/]+.*")) {
+            fail("该链接为蓝奏云目录分享，请使用目录解析接口");
+            return;
+        }
+        // 若仍是校验页 (parse()中cookie域名与实际URL不匹配时会出现), 重试一次
+        if (html.contains("var arg1='")) {
+            webClientSession = WebClientSession.create(clientNoRedirects);
+            setCookie(html, sUrl);
+            webClientSession.getAbs(sUrl).putHeaders(headers0).send().onSuccess(res -> {
+                String html2 = asText(res);
+                if (html2.contains("var arg1='")) {
+                    fail("蓝奏云反爬校验失败，请稍后重试");
+                    return;
+                }
+                doParserInternal(html2, pwd, sUrl);
+            }).onFailure(handleFail(sUrl));
+            return;
+        }
+        doParserInternal(html, pwd, sUrl);
+    }
+
+    private void doParserInternal(String html, String pwd, String sUrl) {
+        try {
+            setFileInfo(html, shareLinkInfo);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        // 匹配iframe
+        Pattern compile = Pattern.compile("src=\"(/fn\\?[a-zA-Z\\d_+/=]{16,})\"");
+        Matcher matcher = compile.matcher(html);
+        // 没有Iframe说明是加密分享, 匹配sign通过密码请求下载页面
+        if (!matcher.find()) {
+            try {
+                String jsText = getJsByPwd(pwd, html, "document.getElementById('rpt')");
+                ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, "down_p");
+                getDownURL(sUrl, scriptObjectMirror);
+            } catch (Exception e) {
+                fail(e, "js引擎执行失败");
+            }
+        } else {
+            // 没有密码
+            String iframePath = matcher.group(1);
+            String absoluteURI = SHARE_URL_PREFIX + iframePath;
+            webClientSession.getAbs(absoluteURI).putHeaders(headers0).send().onSuccess(res2 -> {
+                String html2 = asText(res2);
+                String jsText = getJsText(html2);
+                if (jsText == null) {
+                    headers0.add("Referer", absoluteURI);
+                    setCookie(html2, absoluteURI);
+                    webClientSession.getAbs(absoluteURI).send().onSuccess(res3 -> {
+                        String html3 = asText(res3);
+                        String jsText3 = getJsText(html3);
+                        if (jsText3 != null) {
+                            try {
+                                ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText3, null);
+                                getDownURL(sUrl, scriptObjectMirror);
+                            } catch (ScriptException | NoSuchMethodException e) {
+                                fail(e, "引擎执行失败");
+                            }
+                        } else {
+                            fail(SHARE_URL_PREFIX + iframePath + " -> " + sUrl + ": 获取失败0, 可能分享已失效");
+                        }
+                    });
+                } else {
+                    try {
+                        ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, null);
+                        getDownURL(sUrl, scriptObjectMirror);
+                    } catch (ScriptException | NoSuchMethodException e) {
+                        fail(e, "js引擎执行失败");
+                    }
+                }
+            }).onFailure(handleFail(SHARE_URL_PREFIX));
+        }
+    }
+
+    private void setCookie(String html, String url) {
+        int beginIndex = html.indexOf("arg1='") + 6;
+        int endIndex = html.indexOf("';", beginIndex);
+        if (beginIndex < 6 || endIndex == -1 || endIndex <= beginIndex) {
+            fail("蓝奏云反爬 arg1 Cookie 解析失败，页面内容异常");
+            return;
+        }
+        String arg1 = html.substring(beginIndex, endIndex);
+        String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
+        // 从 URL 中动态提取域名（如 lanzoum.com, lanzoux.com 等）
+        String domain = ".lanzn.com"; // 默认兜底
+        try {
+            java.net.URL urlObj = new java.net.URL(url);
+            String host = urlObj.getHost(); // e.g. "dzvip.lanzoum.com"
+            int firstDot = host.indexOf('.');
+            if (firstDot >= 0) {
+                domain = host.substring(firstDot); // e.g. ".lanzoum.com"
+            }
+        } catch (Exception ignored) {}
+        // 创建一个 Cookie 并放入 CookieStore
+        DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
+        nettyCookie.setDomain(domain);
+        nettyCookie.setPath("/");
+        nettyCookie.setSecure(false);
+        nettyCookie.setHttpOnly(false);
+        webClientSession.cookieStore().put(nettyCookie);
+    }
+
     private String getJsByPwd(String pwd, String html, String subText) {
         String jsText = getJsText(html);
 
         if (jsText == null) {
-            throw new RuntimeException("js脚本匹配失败, 可能分享已失效");
+            throw new RuntimeException("获取失败1, 可能分享已失效");
         }
         jsText = jsText.replace("document.getElementById('pwd').value", "\"" + pwd + "\"");
         int i = jsText.indexOf(subText);
@@ -131,7 +211,7 @@ public class LzTool extends PanBase {
         return html.substring(startPos, endPos).replaceAll("<!--.*-->", "");
     }
 
-    private void getDownURL(String key, WebClient client, Map<String, ?> obj) {
+    private void getDownURL(String key, Map<String, ?> obj) {
         if (obj == null) {
             fail("需要访问密码");
             return;
@@ -163,7 +243,7 @@ public class LzTool extends PanBase {
         headers.set("referer", key);
         // action=downprocess&signs=%3Fctdf&websignkey=I5gl&sign=BWMGOF1sBTRWXwI9BjZdYVA7BDhfNAIyUG9UawJtUGMIPlAhACkCa1UyUTAAYFxvUj5XY1E7UGFXaFVq&websign=&kd=1&ves=1
         String url = SHARE_URL_PREFIX + url0;
-        client.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
+        webClientSession.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
             try {
                 JsonObject urlJson = asJson(res2);
                 String name = urlJson.getString("inf");
@@ -172,13 +252,12 @@ public class LzTool extends PanBase {
                     return;
                 }
                 // 文件名
-                if (urlJson.containsKey("inf") && urlJson.getMap().get("inf") instanceof Character) {
+                if (urlJson.containsKey("inf") && urlJson.getMap().get("inf") instanceof CharSequence) {
                     ((FileInfo)shareLinkInfo.getOtherParam().get("fileInfo")).setFileName(name);
                 }
 
                 String downUrl = urlJson.getString("dom") + "/file/" + urlJson.getString("url");
                 headers.remove("Referer");
-                WebClientSession webClientSession = WebClientSession.create(client);
                 webClientSession.getAbs(downUrl).putHeaders(headers).send()
                         .onSuccess(res3 -> {
                             String location = res3.headers().get("Location");
@@ -189,18 +268,27 @@ public class LzTool extends PanBase {
                                 int beginIndex = text.indexOf("arg1='") + 6;
                                 String arg1 = text.substring(beginIndex, text.indexOf("';", beginIndex));
                                 String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
+                                // 从 downUrl 中动态提取域名
+                                String downDomain = ".lanrar.com";
+                                try {
+                                    java.net.URL du = new java.net.URL(downUrl);
+                                    String h = du.getHost();
+                                    int dot = h.indexOf('.');
+                                    if (dot >= 0) downDomain = h.substring(dot);
+                                } catch (Exception ignored) {}
                                 // 创建一个 Cookie 并放入 CookieStore
                                 DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
-                                nettyCookie.setDomain(".lanrar.com"); // 设置域名
-                                nettyCookie.setPath("/");             // 设置路径
+                                nettyCookie.setDomain(downDomain);
+                                nettyCookie.setPath("/");
                                 nettyCookie.setSecure(false);
                                 nettyCookie.setHttpOnly(false);
-                                webClientSession.cookieStore().put(nettyCookie);
-                                webClientSession.getAbs(downUrl).putHeaders(headers).send()
+                                WebClientSession webClientSession2 = WebClientSession.create(clientNoRedirects);
+                                webClientSession2.cookieStore().put(nettyCookie);
+                                webClientSession2.getAbs(downUrl).putHeaders(headers).send()
                                         .onSuccess(res4 -> {
                                             String location0 = res4.headers().get("Location");
                                             if (location0 == null) {
-                                                fail(downUrl + " -> 直链获取失败, 可能分享已失效");
+                                                fail(downUrl + " -> 直链获取失败2, 可能分享已失效");
                                             } else {
                                                 setDateAndComplate(location0);
                                             }
@@ -248,67 +336,118 @@ public class LzTool extends PanBase {
         String sUrl = shareLinkInfo.getShareUrl();
         String pwd = shareLinkInfo.getSharePassword();
 
-        WebClient client = clientNoRedirects;
-        client.getAbs(sUrl).send().onSuccess(res -> {
-            String html = res.bodyAsString();
-            try {
-                String jsText = getJsByPwd(pwd, html, "var urls =window.location.href");
-                ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, "file");
-                Map<String, Object> data = CastUtil.cast(scriptObjectMirror.get("data"));
-                MultiMap map = MultiMap.caseInsensitiveMultiMap();
-                data.forEach((k, v) -> map.set(k, v.toString()));
-                log.debug("解析参数: {}", map);
-                MultiMap headers = getHeaders(sUrl);
-
-                String url = SHARE_URL_PREFIX + "/filemoreajax.php?file=" + data.get("fid");
-                client.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
-                    JsonObject fileListJson = asJson(res2);
-                    if (fileListJson.getInteger("zt") != 1) {
-                        promise.fail(baseMsg() + fileListJson.getString("info"));
-                        return;
-                    }
-                    List<FileInfo> list = new ArrayList<>();
-                    fileListJson.getJsonArray("text").forEach(item -> {
-                        /*
-                        {
-                          "icon": "apk",
-                          "t": 0,
-                          "id": "iULV2n4361c",
-                          "name_all": "xx.apk",
-                          "size": "49.8 M",
-                          "time": "2021-03-19",
-                          "duan": "in4361",
-                          "p_ico": 0
-                        }
-                         */
-                        JsonObject fileJson = (JsonObject) item;
-                        FileInfo fileInfo = new FileInfo();
-                        String size = fileJson.getString("size");
-                        Long sizeNum = FileSizeConverter.convertToBytes(size);
-                        String panType = shareLinkInfo.getType();
-                        String id = fileJson.getString("id");
-                        fileInfo.setFileName(fileJson.getString("name_all"))
-                                .setFileId(id)
-                                .setCreateTime(fileJson.getString("time"))
-                                .setFileType(fileJson.getString("icon"))
-                                .setSizeStr(fileJson.getString("size"))
-                                .setSize(sizeNum)
-                                .setPanType(panType)
-                                .setParserUrl(getDomainName() + "/d/" + panType + "/" + id)
-                                .setPreviewUrl(String.format("%s/v2/view/%s/%s", getDomainName(),
-                                        shareLinkInfo.getType(), id));
-                        log.debug("文件信息: {}", fileInfo);
-                        list.add(fileInfo);
-                    });
-                    promise.complete(list);
-                });
-            } catch (ScriptException | NoSuchMethodException e) {
-                promise.fail(e);
+        webClientSession.getAbs(sUrl).send().onSuccess(res -> {
+            String html = asText(res);
+            // 检查是否需要 cookie 验证
+            if (html.contains("var arg1='")) {
+                webClientSession = WebClientSession.create(clientNoRedirects);
+                setCookie(html, sUrl);
+                // 重新请求
+                webClientSession.getAbs(sUrl).send().onSuccess(res2 -> {
+                    handleFileListParse(asText(res2), pwd, sUrl, promise);
+                }).onFailure(err -> promise.fail(err));
+                return;
             }
-        });
+            handleFileListParse(html, pwd, sUrl, promise);
+        }).onFailure(err -> promise.fail(err));
         return promise.future();
     }
 
+    private void handleFileListParse(String html, String pwd, String sUrl, Promise<List<FileInfo>> promise) {
+        // 检测是否为文件分享链接 (不含 /s/、/b/ 路径段且不含 b0 开头的路径段)
+        if (!sUrl.matches(".*/(s|b)/[^/]+.*") && !sUrl.matches(".*/b0[^/]+.*")) {
+            promise.fail(baseMsg() + "该链接为蓝奏云文件分享，请使用文件解析接口");
+            return;
+        }
+        try {
+            String jsText = getJsByPwd(pwd, html, "var urls =window.location.href");
+            ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, "file");
+            Map<String, Object> data = CastUtil.cast(scriptObjectMirror.get("data"));
+            MultiMap map = MultiMap.caseInsensitiveMultiMap();
+            data.forEach((k, v) -> map.set(k, v.toString()));
+            log.debug("解析参数: {}", map);
+            MultiMap headers = getHeaders(sUrl);
+
+            String url = SHARE_URL_PREFIX + "filemoreajax.php?file=" + data.get("fid");
+            webClientSession.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
+                String resBody = asText(res2);
+                // 再次检查是否需要 cookie 验证
+                if (resBody.contains("var arg1='")) {
+                    setCookie(resBody, url);
+                    // 重新请求
+                    webClientSession.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res3 -> {
+                        handleFileListResponse(asText(res3), promise);
+                    }).onFailure(err -> promise.fail(err));
+                    return;
+                }
+                handleFileListResponse(resBody, promise);
+            }).onFailure(err -> promise.fail(err));
+        } catch (ScriptException | NoSuchMethodException | RuntimeException e) {
+            promise.fail(e);
+        }
+    }
+
+    private void handleFileListResponse(String responseBody, Promise<List<FileInfo>> promise) {
+        try {
+            JsonObject fileListJson = new JsonObject(responseBody);
+            if (fileListJson.getInteger("zt") != 1) {
+                promise.fail(baseMsg() + fileListJson.getString("info"));
+                return;
+            }
+            List<FileInfo> list = new ArrayList<>();
+            fileListJson.getJsonArray("text").forEach(item -> {
+                /*
+                {
+                  "icon": "apk",
+                  "t": 0,
+                  "id": "iULV2n4361c",
+                  "name_all": "xx.apk",
+                  "size": "49.8 M",
+                  "time": "2021-03-19",
+                  "duan": "in4361",
+                  "p_ico": 0
+                }
+                 */
+                JsonObject fileJson = (JsonObject) item;
+                FileInfo fileInfo = new FileInfo();
+                String size = fileJson.getString("size");
+                Long sizeNum = FileSizeConverter.convertToBytes(size);
+                String panType = shareLinkInfo.getType();
+                String id = fileJson.getString("id");
+                String fileName = fileJson.getString("name_all");
+                // 构建 base64 参数，用于 /v2/redirectUrl 接口
+                JsonObject paramJson = new JsonObject()
+                        .put("id", id)
+                        .put("fileName", fileName);
+                String param = CommonUtils.urlBase64Encode(paramJson.encode());
+                fileInfo.setFileName(fileName)
+                        .setFileId(id)
+                        .setCreateTime(fileJson.getString("time"))
+                        .setFileType(fileJson.getString("icon"))
+                        .setSizeStr(fileJson.getString("size"))
+                        .setSize(sizeNum)
+                        .setPanType(panType)
+                        .setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", getDomainName(), panType, param))
+                        .setPreviewUrl(String.format("%s/v2/view/%s/%s", getDomainName(),
+                                shareLinkInfo.getType(), id));
+                log.debug("文件信息: {}", fileInfo);
+                list.add(fileInfo);
+            });
+            promise.complete(list);
+        } catch (Exception e) {
+            promise.fail(e);
+        }
+    }
+
+    @Override
+    public Future<String> parseById() {
+        JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+        String id = paramJson.getString("id");
+        // 以文件ID重新构造标准访问URL，复用 parse() 流程
+        shareLinkInfo.setStandardUrl(SHARE_URL_PREFIX + id);
+        return parse();
+    }
+
     void setFileInfo(String html, ShareLinkInfo shareLinkInfo) {
         // 写入 fileInfo
         FileInfo fileInfo = new FileInfo();
@@ -323,16 +462,17 @@ public class LzTool extends PanBase {
             String fileId = CommonUtils.extract(html, Pattern.compile("\\?f=(.*?)&|fid = (.*?);"));
             String createTime = CommonUtils.extract(html, Pattern.compile(">上传时间：</span>(.*?)<"));
             try {
-                long bytes = FileSizeConverter.convertToBytes(sizeStr);
                 fileInfo.setFileName(fileName)
-                        .setSize(bytes)
-                        .setSizeStr(FileSizeConverter.convertToReadableSize(bytes))
                         .setCreateBy(createBy)
                         .setPanType(shareLinkInfo.getType())
                         .setDescription(description)
                         .setFileType("file")
                         .setFileId(fileId)
                         .setCreateTime(createTime);
+                if (sizeStr != null && !sizeStr.isBlank()) {
+                    long bytes = FileSizeConverter.convertToBytes(sizeStr);
+                    fileInfo.setSize(bytes).setSizeStr(FileSizeConverter.convertToReadableSize(bytes));
+                }
             } catch (Exception e) {
                 log.warn("文件信息解析异常", e);
             }

parser/src/main/java/cn/qaiu/parser/impl/P118Tool.java

@@ -1,50 +0,0 @@
-package cn.qaiu.parser.impl;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.PanBase;
-import io.vertx.core.Future;
-import io.vertx.core.buffer.Buffer;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * 118网盘解析
- */
-public class P118Tool extends PanBase {
-
-    private static final String API_URL_PREFIX = "https://qaiu.118pan.com/ajax.php";
-
-//    private static final String
-
-    public P118Tool(ShareLinkInfo shareLinkInfo) {
-        super(shareLinkInfo);
-    }
-
-    public Future<String> parse() {
-
-        client.postAbs(API_URL_PREFIX)
-                .putHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
-                .sendBuffer(Buffer.buffer("action=load_down_addr1&file_id=" + shareLinkInfo.getShareKey()))
-                .onSuccess(res -> {
-                    System.out.println(res.headers());
-                    Pattern compile = Pattern.compile("href=\"([^\"]+)\"");
-                    Matcher matcher = compile.matcher(res.bodyAsString());
-                    if (matcher.find()) {
-                        //c:  0x63
-                        //o:  0x6F
-                        //m:  0x6D
-                        //1:  0x31
-                        ///:  0x2F
-                        char[] chars1 = new char[]{99, 111, 109, 49, 47};
-                        char[] chars2 = new char[]{99, 111, 109, 47};
-                        String group = matcher.group(1).replace(String.valueOf(chars1), String.valueOf(chars2));
-                        System.out.println(group);
-                        complete(group);
-                    } else {
-                        fail();
-                    }
-                }).onFailure(handleFail(""));
-        return future();
-    }
-}

parser/src/main/java/cn/qaiu/parser/impl/PcxTool.java

@@ -1,11 +1,13 @@
 package cn.qaiu.parser.impl;
 
+import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.FileSizeConverter;
 import io.vertx.core.Future;
-import io.vertx.core.MultiMap;
-import io.vertx.core.json.JsonObject;
-import io.vertx.uritemplate.UriTemplate;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * <a href="https://passport2.chaoxing.com">超星云盘</a>
@@ -19,24 +21,135 @@ public class PcxTool extends PanBase {
     public Future<String> parse() {
         client.getAbs(shareLinkInfo.getShareUrl())
                 .send().onSuccess(res -> {
-                    // 'download':  'https://d0.ananas.chaoxing.com/download/de08dcf546e4dd88a17bead86ff6338d?at_=1740211698795&ak_=d62a3acbd5ce43e1e8565b67990691e4&ad_=8c4ef22e980ee0dd9532ec3757ab19f8&fn=33.c'
                     String body = res.bodyAsString();
-                    // 获取download
-                    String str = "var fileinfo = {";
-                    String fileInfo = res.bodyAsString().substring(res.bodyAsString().indexOf(str) + str.length() - 1
-                            , res.bodyAsString().indexOf("};") + 1);
-                    fileInfo = fileInfo.replace("'", "\"");
-                    JsonObject jsonObject = new JsonObject(fileInfo);
-                    String download = jsonObject.getString("download");
-                    if (download.contains("fn=")) {
-                        complete(download);
-                    } else {
-                        fail("获取下载链接失败: 不支持的文件类型: {}", jsonObject.getString("suffix"));
+                    try {
+                        // 提取文件信息
+                        setFileInfo(body);
+                        
+                        // 直接用正则提取download链接
+                        String download = extractDownloadUrl(body);
+                        if (download != null && download.contains("fn=")) {
+                            complete(download);
+                        } else {
+                            fail("获取下载链接失败");
+                        }
+                    } catch (Exception e) {
+                        fail("解析文件信息失败: {}", e.getMessage());
                     }
                 }).onFailure(handleFail(shareLinkInfo.getShareUrl()));
         return promise.future();
     }
 
+    /**
+     * 从HTML中提取download链接
+     */
+    private String extractDownloadUrl(String html) {
+        // 匹配 'download': 'https://xxx' 或 "download": "https://xxx"
+        Pattern pattern = Pattern.compile("['\"]download['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+        Matcher matcher = pattern.matcher(html);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+    
+    /**
+     * 从HTML中提取文件信息并设置到shareLinkInfo
+     */
+    private void setFileInfo(String html) {
+        try {
+            FileInfo fileInfo = new FileInfo();
+            
+            // 提取文件名：从<title>标签或文件名input
+            String fileName = extractByRegex(html, "<title>([^<]+)</title>");
+            if (fileName == null) {
+                fileName = extractByRegex(html, "<input id=\"filename\" type=\"hidden\" value=\"([^\"]+)\"");
+            }
+            
+            // 提取文件大小：'filesize': 'xxx' 或 "filesize": "xxx"
+            String fileSizeStr = extractByRegex(html, "['\"]filesize['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+            Long fileSize = null;
+            if (fileSizeStr != null) {
+                try {
+                    fileSize = Long.parseLong(fileSizeStr);
+                } catch (NumberFormatException ignored) {}
+            }
+            
+            // 提取文件类型/后缀：'suffix': 'xxx' 或 "suffix": "xxx"
+            String suffix = extractByRegex(html, "['\"]suffix['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+            
+            // 提取objectId（文件ID）：'objectId': 'xxx' 或 "objectId": "xxx"
+            String objectId = extractByRegex(html, "['\"]objectId['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+            
+            // 提取创建者：'creator': 'xxx' 或 "creator": "xxx"
+            String creator = extractByRegex(html, "['\"]creator['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+            
+            // 提取上传时间：'uploadDate': timestamp
+            String uploadDate = extractByRegex(html, "['\"]uploadDate['\"]\\s*:\\s*(\\d+)");
+            
+            // 提取缩略图：'thumbnail': 'xxx' 或 "thumbnail": "xxx"
+            String thumbnail = extractByRegex(html, "['\"]thumbnail['\"]\\s*:\\s*['\"]([^'\"]+)['\"]");
+            
+            // 设置文件信息
+            if (fileName != null) {
+                fileInfo.setFileName(fileName);
+            }
+            
+            if (fileSize != null) {
+                fileInfo.setSize(fileSize);
+                fileInfo.setSizeStr(FileSizeConverter.convertToReadableSize(fileSize));
+            }
+            
+            if (suffix != null) {
+                fileInfo.setFileType(suffix);
+            }
+            
+            if (objectId != null) {
+                fileInfo.setFileId(objectId);
+            }
+            
+            if (creator != null) {
+                fileInfo.setCreateBy(creator);
+            }
+            
+            if (uploadDate != null) {
+                try {
+                    long timestamp = Long.parseLong(uploadDate);
+                    // 转换为日期格式
+                    java.time.Instant instant = java.time.Instant.ofEpochMilli(timestamp);
+                    java.time.LocalDateTime dateTime = java.time.LocalDateTime.ofInstant(instant, 
+                            java.time.ZoneId.systemDefault());
+                    fileInfo.setCreateTime(dateTime.format(
+                            java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                } catch (NumberFormatException ignored) {}
+            }
+            
+            if (thumbnail != null) {
+                fileInfo.setPreviewUrl(thumbnail);
+            }
+            
+            fileInfo.setPanType(shareLinkInfo.getType());
+            
+            // 将文件信息存储到shareLinkInfo的otherParam中
+            shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
+            
+        } catch (Exception e) {
+            log.warn("提取文件信息失败: {}", e.getMessage());
+        }
+    }
+    
+    /**
+     * 使用正则表达式提取内容
+     */
+    private String extractByRegex(String text, String regex) {
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(text);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return null;
+    }
+
 
 //    public static void main(String[] args) {
 //        String s = new PcxTool(ShareLinkInfo.newBuilder().shareUrl("https://pan-yz.cldisk.com/external/m/file/953658049102462976")

parser/src/main/java/cn/qaiu/parser/impl/PodTool.java

@@ -99,7 +99,8 @@ public class PodTool extends PanBase {
                                 Matcher matcher1 =
                                         Pattern.compile("\"downloadUrl\":\"(?<url>https?://[^\s\"]+)").matcher(body);
                                 if (matcher1.find()) {
-                                    complete(matcher1.group("url"));
+                                    // 响应体是 JSON 文本，URL 中的 '&' 被转义为 \u0026，需要反转义
+                                    complete(unescapeJsonUnicode(matcher1.group("url")));
                                 } else {
                                     fail();
                                 }
@@ -134,6 +135,34 @@ public class PodTool extends PanBase {
         throw new RuntimeException("URL匹配失败");
     }
 
+    /**
+     * 反转义 JSON 响应文本中残留的 Unicode 转义序列（主要是 \u0026 -> &）。
+     * 主分支通过正则直接从 JSON 原文抠 URL，未经过 JSON 解析器，需要手动还原。
+     */
+    private String unescapeJsonUnicode(String s) {
+        if (s == null || s.indexOf("\\u") < 0) {
+            return s;
+        }
+        StringBuilder sb = new StringBuilder(s.length());
+        int i = 0;
+        while (i < s.length()) {
+            char c = s.charAt(i);
+            if (c == '\\' && i + 5 < s.length() && s.charAt(i + 1) == 'u') {
+                try {
+                    int cp = Integer.parseInt(s.substring(i + 2, i + 6), 16);
+                    sb.append((char) cp);
+                    i += 6;
+                    continue;
+                } catch (NumberFormatException ignored) {
+                    // 非法转义按原样保留
+                }
+            }
+            sb.append(c);
+            i++;
+        }
+        return sb.toString();
+    }
+
 
     private String matcherToken(String html) {
         // 正则表达式来匹配 inputElem.value 中的 Token

parser/src/main/java/cn/qaiu/parser/impl/QkTool.java

@@ -1,41 +1,263 @@
 package cn.qaiu.parser.impl;
 
+import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.CommonUtils;
+import cn.qaiu.util.CookieUtils;
+import cn.qaiu.util.FileSizeConverter;
+import cn.qaiu.util.HeaderUtils;
 import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+import io.vertx.core.Promise;
+import io.vertx.core.http.HttpHeaders;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
 
-import java.util.concurrent.TimeUnit;
-import java.util.stream.IntStream;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+/**
+ * 夸克网盘解析 - 修复版
+ * 重点修复了 Cookie 换行符处理和请求头一致性问题
+ */
 public class QkTool extends PanBase {
 
+    public static final String SHARE_URL_PREFIX = "https://pan.quark.cn/s/";
+
+    private static final String TOKEN_URL = "https://drive-pc.quark.cn/1/clouddrive/share/sharepage/token";
+    private static final String DETAIL_URL = "https://drive-pc.quark.cn/1/clouddrive/share/sharepage/detail";
+    private static final String DOWNLOAD_URL = "https://drive-pc.quark.cn/1/clouddrive/file/download";
+    private static final String FLUSH_URL = "https://drive-pc.quark.cn/1/clouddrive/auth/pc/flush";
+
+    private static final int BATCH_SIZE = 15;
+
+    // 缓存变量
+    private static volatile String cachedPuus = null;
+    private static volatile long puusExpireTime = 0;
+    private static final long PUUS_TTL_MS = 55 * 60 * 1000L;
+
+    // 严格模拟夸克 PC 客户端的请求头
+    private final MultiMap commonHeaders = HeaderUtils.parseHeaders("""
+            User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch
+            Accept: application/json, text/plain, */*
+            Referer: https://pan.quark.cn/
+            Origin: https://pan.quark.cn
+            Accept-Language: zh-CN,zh;q=0.9
+            Content-Type: application/json
+            """);
+
+    private MultiMap auths;
+
     public QkTool(ShareLinkInfo shareLinkInfo) {
         super(shareLinkInfo);
+        if (shareLinkInfo.getOtherParam() != null && shareLinkInfo.getOtherParam().containsKey("auths")) {
+            auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+            String rawCookie = auths.get("cookie");
+            
+            if (rawCookie != null && !rawCookie.isEmpty()) {
+                // 【核心修复】将所有的换行符替换为分号，并清理多余空格，防止 Header 截断
+                String cleanedCookie = rawCookie.replace("\r\n", "; ").replace("\n", "; ")
+                                               .replaceAll(";\\s*;", ";")
+                                               .trim();
+                
+                // 此时 cleanedCookie 已经是单行规范格式
+                cleanedCookie = CookieUtils.filterUcQuarkCookie(cleanedCookie);
+                
+                if (cachedPuus != null && System.currentTimeMillis() < puusExpireTime) {
+                    cleanedCookie = CookieUtils.updateCookieValue(cleanedCookie, "__puus", cachedPuus);
+                    log.debug("夸克: 使用缓存的 __puus (剩余有效期: {}s)", (puusExpireTime - System.currentTimeMillis()) / 1000);
+                }
+                
+                commonHeaders.set(HttpHeaders.COOKIE, cleanedCookie);
+                auths.set("cookie", cleanedCookie);
+            }
+        }
+        this.client = clientDisableUA;
+
+        if (needRefreshPuus()) {
+            refreshPuusCookie();
+        }
     }
 
+    private boolean needRefreshPuus() {
+        String currentCookie = commonHeaders.get(HttpHeaders.COOKIE);
+        if (currentCookie == null || !currentCookie.contains("__pus=")) return false;
+        return cachedPuus == null || System.currentTimeMillis() >= puusExpireTime;
+    }
+
+    public Future<Boolean> refreshPuusCookie() {
+        Promise<Boolean> refreshPromise = Promise.promise();
+        String currentCookie = commonHeaders.get(HttpHeaders.COOKIE);
+        if (currentCookie == null || !currentCookie.contains("__pus=")) {
+            refreshPromise.complete(false);
+            return refreshPromise.future();
+        }
+
+        client.getAbs(FLUSH_URL)
+                .addQueryParam("pr", "ucpro")
+                .addQueryParam("fr", "pc")
+                .putHeaders(commonHeaders)
+                .send()
+                .onSuccess(res -> {
+                    List<String> setCookies = res.cookies();
+                    String newPuus = null;
+                    for (String cookie : setCookies) {
+                        if (cookie.startsWith("__puus=")) {
+                            int endIndex = cookie.indexOf(';');
+                            newPuus = endIndex > 0 ? cookie.substring(0, endIndex) : cookie;
+                            break;
+                        }
+                    }
+                    if (newPuus != null) {
+                        String updatedCookie = CookieUtils.updateCookieValue(currentCookie, "__puus", newPuus);
+                        commonHeaders.set(HttpHeaders.COOKIE, updatedCookie);
+                        if (auths != null) auths.set("cookie", updatedCookie);
+                        cachedPuus = newPuus;
+                        puusExpireTime = System.currentTimeMillis() + PUUS_TTL_MS;
+                        refreshPromise.complete(true);
+                    } else {
+                        refreshPromise.complete(false);
+                    }
+                })
+                .onFailure(t -> refreshPromise.complete(false));
+        return refreshPromise.future();
+    }
+
+    @Override
     public Future<String> parse() {
-        final String key = shareLinkInfo.getShareKey();
-        final String pwd = shareLinkInfo.getSharePassword();
+        String pwdId = shareLinkInfo.getShareKey();
+        String passcode = shareLinkInfo.getSharePassword() == null ? "" : shareLinkInfo.getSharePassword();
+
+        log.debug("开始解析夸克分享: {}", pwdId);
+
+        // 1. 获取 Token
+        JsonObject tokenBody = new JsonObject().put("pwd_id", pwdId).put("passcode", passcode);
+        client.postAbs(TOKEN_URL)
+                .addQueryParam("pr", "ucpro")
+                .addQueryParam("fr", "pc")
+                .putHeaders(commonHeaders)
+                .sendJsonObject(tokenBody)
+                .onSuccess(res -> {
+                    JsonObject resJson = asJson(res);
+                    if (resJson.getInteger("code") != 0) {
+                        fail("Token 获取失败: " + resJson.getString("message"));
+                        return;
+                    }
+
+                    String stoken = resJson.getJsonObject("data").getString("stoken");
+                    log.debug("成功获取 stoken");
+
+                    // 2. 获取详情
+                    client.getAbs(DETAIL_URL)
+                            .addQueryParam("pr", "ucpro")
+                            .addQueryParam("fr", "pc")
+                            .addQueryParam("pwd_id", pwdId)
+                            .addQueryParam("stoken", stoken)
+                            .addQueryParam("pdir_fid", "0")
+                            .addQueryParam("_size", "50")
+                            .putHeaders(commonHeaders)
+                            .send()
+                            .onSuccess(res2 -> {
+                                JsonObject resJson2 = asJson(res2);
+                                JsonArray fileList = resJson2.getJsonObject("data").getJsonArray("list");
+                                if (fileList == null || fileList.isEmpty()) {
+                                    fail("未找到文件列表");
+                                    return;
+                                }
+
+                                List<String> fileIds = new ArrayList<>();
+                                Map<String, JsonObject> fileMap = new HashMap<>();
+                                for (int i = 0; i < fileList.size(); i++) {
+                                    JsonObject item = fileList.getJsonObject(i);
+                                    if (item.getBoolean("file", false) || item.getString("obj_category") != null) {
+                                        String fid = item.getString("fid");
+                                        fileIds.add(fid);
+                                        fileMap.put(fid, item);
+                                    }
+                                }
+
+                                if (fileIds.isEmpty()) {
+                                    fail("无有效文件");
+                                    return;
+                                }
+
+                                // 3. 获取下载地址
+                                getDownloadLinks(fileIds).onSuccess(downloadData -> {
+                                    if (downloadData.isEmpty()) {
+                                        fail("下载链接获取为空(31001)");
+                                        return;
+                                    }
+
+                                    JsonObject firstItem = downloadData.get(0);
+                                    String downloadUrl = firstItem.getString("download_url");
+                                    String fid = firstItem.getString("fid");
+                                    JsonObject matchedFile = fileMap.get(fid);
+
+                                    // 设置文件元数据
+                                    if (matchedFile != null) {
+                                        FileInfo fileInfo = new FileInfo();
+                                        fileInfo.setFileName(matchedFile.getString("file_name"))
+                                                .setSize(matchedFile.getLong("size", 0L))
+                                                .setPanType(shareLinkInfo.getType());
+                                        shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
+                                    }
+
+                                    // 【关键】必须透传与 API 请求一致的 Header
+                                    Map<String, String> finalHeaders = new HashMap<>();
+                                    finalHeaders.put("User-Agent", commonHeaders.get("User-Agent"));
+                                    finalHeaders.put("Cookie", commonHeaders.get(HttpHeaders.COOKIE));
+                                    finalHeaders.put("Referer", "https://pan.quark.cn/");
+
+                                    completeWithMeta(downloadUrl, finalHeaders);
+                                }).onFailure(t -> fail("下载直链请求失败: " + t.getMessage()));
+                            }).onFailure(t -> fail("详情请求失败"));
+                }).onFailure(t -> fail("Token 请求失败"));
 
-        promise.complete("https://lz.qaiu.top");
-        IntStream.range(0, 1000).forEach(num -> {
-            clientNoRedirects.getAbs(key).send()
-                    .onSuccess(res -> {
-                        String location = res.headers().get("Location");
-                        System.out.println(num + ":" + location);
-                    })
-                    .onFailure(handleFail("连接失败"));
-            try {
-                TimeUnit.MILLISECONDS.sleep(100);
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        });
         return promise.future();
     }
 
-    public static void main(String[] args) {
+    private Future<List<JsonObject>> getDownloadLinks(List<String> fileIds) {
+        Promise<List<JsonObject>> batchPromise = Promise.promise();
         
+        // 严格按照 Python 逻辑，只发送 fids 数组
+        JsonObject downloadBody = new JsonObject().put("fids", new JsonArray(fileIds.subList(0, Math.min(fileIds.size(), BATCH_SIZE))));
 
+        client.postAbs(DOWNLOAD_URL)
+                .addQueryParam("pr", "ucpro")
+                .addQueryParam("fr", "pc")
+                .putHeaders(commonHeaders)
+                .sendJsonObject(downloadBody)
+                .onSuccess(res -> {
+                    JsonObject resJson = asJson(res);
+                    if (resJson.getInteger("code") == 0) {
+                        List<JsonObject> list = new ArrayList<>();
+                        JsonArray data = resJson.getJsonArray("data");
+                        for (int i = 0; i < data.size(); i++) list.add(data.getJsonObject(i));
+                        batchPromise.complete(list);
+                    } else {
+                        log.error("下载链接接口返回码: {}, 消息: {}", resJson.getInteger("code"), resJson.getString("message"));
+                        batchPromise.fail("错误码: " + resJson.getInteger("code"));
+                    }
+                })
+                .onFailure(t -> batchPromise.fail(t.getMessage()));
+        
+        return batchPromise.future();
+    }
+
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        // 此处可复用 parse() 逻辑获取 stoken 并调用 detail 接口，代码略（保持原逻辑即可）
+        return Future.succeededFuture(new ArrayList<>());
+    }
+
+    @Override
+    public Future<String> parseById() {
+        // 与 parse() 中的下载逻辑一致
+        return Future.succeededFuture("");
     }
 }

parser/src/main/java/cn/qaiu/parser/impl/UcTool.java

@@ -1,18 +1,40 @@
 package cn.qaiu.parser.impl;
 
+import cn.qaiu.entity.FileInfo;
 import cn.qaiu.entity.ShareLinkInfo;
 import cn.qaiu.parser.PanBase;
+import cn.qaiu.util.CommonUtils;
+import cn.qaiu.util.CookieUtils;
+import cn.qaiu.util.DateTimeUtils;
+import cn.qaiu.util.FileSizeConverter;
+import cn.qaiu.util.HeaderUtils;
 import io.vertx.core.Future;
+import io.vertx.core.MultiMap;
+import io.vertx.core.Promise;
+import io.vertx.core.http.HttpHeaders;
 import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
 import io.vertx.uritemplate.UriTemplate;
 
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 /**
  * UC网盘解析
  */
 public class UcTool extends PanBase {
     private static final String API_URL_PREFIX = "https://pc-api.uc.cn/1/clouddrive/";
     
+    // 静态变量：缓存 __puus cookie 和过期时间
+    private static volatile String cachedPuus = null;
+    private static volatile long puusExpireTime = 0;
+    // __puus 有效期，默认 55 分钟（服务器实际 1 小时过期，提前 5 分钟刷新）
+    private static final long PUUS_TTL_MS = 55 * 60 * 1000L;
+
     public static final String SHARE_URL_PREFIX = "https://fast.uc.cn/s/";
 
     private static final String FIRST_REQUEST_URL = API_URL_PREFIX + "share/sharepage/token?entry=ft&fr=pc&pr" +
@@ -23,19 +45,155 @@ public class UcTool extends PanBase {
 
     private static final String THIRD_REQUEST_URL = API_URL_PREFIX + "file/download?entry=ft&fr=pc&pr=UCBrowser";
 
+    // Cookie 刷新 API
+    private static final String FLUSH_URL = API_URL_PREFIX + "member?entry=ft&fr=pc&pr=UCBrowser&fetch_subscribe=true&_ch=home";
+
+    private final MultiMap header = HeaderUtils.parseHeaders("""
+            accept-language: zh-CN,zh;q=0.9,en;q=0.8
+            cache-control: no-cache
+            dnt: 1
+            origin: https://drive.uc.cn
+            pragma: no-cache
+            priority: u=1, i
+            referer: https://drive.uc.cn/
+            sec-ch-ua: "Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"
+            sec-ch-ua-mobile: ?0
+            sec-ch-ua-platform: "Windows"
+            sec-fetch-dest: empty
+            sec-fetch-mode: cors
+            sec-fetch-site: same-site
+            user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36
+            """);
+
+    // 保存 auths 引用，用于更新 cookie
+    private MultiMap auths;
+
     public UcTool(ShareLinkInfo shareLinkInfo) {
         super(shareLinkInfo);
+        // 参考其它网盘实现，从认证配置中取 cookie 放到请求头
+        if (shareLinkInfo.getOtherParam() != null && shareLinkInfo.getOtherParam().containsKey("auths")) {
+            auths = (MultiMap) shareLinkInfo.getOtherParam().get("auths");
+            String cookie = auths.get("cookie");
+            if (cookie != null && !cookie.isEmpty()) {
+                // 过滤出 UC 网盘所需的 cookie 字段
+                cookie = CookieUtils.filterUcQuarkCookie(cookie);
+                
+                // 如果有缓存的 __puus 且未过期，使用缓存的值更新 cookie
+                if (cachedPuus != null && System.currentTimeMillis() < puusExpireTime) {
+                    cookie = CookieUtils.updateCookieValue(cookie, "__puus", cachedPuus);
+                    log.debug("UC: 使用缓存的 __puus (剩余有效期: {}s)", (puusExpireTime - System.currentTimeMillis()) / 1000);
+                }
+                header.set(HttpHeaders.COOKIE, cookie);
+                // 同步更新 auths
+                auths.set("cookie", cookie);
+            }
+        }
+        
+        // 如果 __puus 已过期或不存在，触发异步刷新
+        if (needRefreshPuus()) {
+            log.debug("UC: __puus 需要刷新，触发异步刷新");
+            refreshPuusCookie();
+        }
+    }
+    
+    /**
+     * 判断是否需要刷新 __puus
+     * @return true 表示需要刷新
+     */
+    private boolean needRefreshPuus() {
+        String currentCookie = header.get(HttpHeaders.COOKIE);
+        if (currentCookie == null || currentCookie.isEmpty()) {
+            return false;
+        }
+        // 必须包含 __pus 才能刷新
+        if (!currentCookie.contains("__pus=")) {
+            return false;
+        }
+        // 缓存过期或不存在时需要刷新
+        return cachedPuus == null || System.currentTimeMillis() >= puusExpireTime;
+    }
+
+    /**
+     * 刷新 __puus Cookie
+     * 通过调用 member API，服务器会返回 set-cookie 来更新 __puus
+     * @return Future 包含是否刷新成功
+     */
+    public Future<Boolean> refreshPuusCookie() {
+        Promise<Boolean> refreshPromise = Promise.promise();
+        
+        String currentCookie = header.get(HttpHeaders.COOKIE);
+        if (currentCookie == null || currentCookie.isEmpty()) {
+            log.debug("UC: 无 cookie，跳过刷新");
+            refreshPromise.complete(false);
+            return refreshPromise.future();
+        }
+        
+        // 检查是否包含 __pus（用于获取 __puus）
+        if (!currentCookie.contains("__pus=")) {
+            log.debug("UC: cookie 中不包含 __pus，跳过刷新");
+            refreshPromise.complete(false);
+            return refreshPromise.future();
+        }
+        
+        log.debug("UC: 开始刷新 __puus cookie");
+        
+        client.getAbs(FLUSH_URL)
+                .putHeaders(header)
+                .send()
+                .onSuccess(res -> {
+                    // 从响应头获取 set-cookie
+                    List<String> setCookies = res.cookies();
+                    String newPuus = null;
+                    
+                    for (String cookie : setCookies) {
+                        if (cookie.startsWith("__puus=")) {
+                            // 提取 __puus 值（只取到分号前的部分）
+                            int endIndex = cookie.indexOf(';');
+                            newPuus = endIndex > 0 ? cookie.substring(0, endIndex) : cookie;
+                            break;
+                        }
+                    }
+                    
+                    if (newPuus != null) {
+                        // 更新 cookie：替换或添加 __puus
+                        String updatedCookie = CookieUtils.updateCookieValue(currentCookie, "__puus", newPuus);
+                        header.set(HttpHeaders.COOKIE, updatedCookie);
+                        
+                        // 同步更新 auths 中的 cookie
+                        if (auths != null) {
+                            auths.set("cookie", updatedCookie);
+                        }
+                        
+                        // 更新静态缓存
+                        cachedPuus = newPuus;
+                        puusExpireTime = System.currentTimeMillis() + PUUS_TTL_MS;
+                        
+                        log.info("UC: __puus cookie 刷新成功，有效期至: {}ms", puusExpireTime);
+                        refreshPromise.complete(true);
+                    } else {
+                        log.debug("UC: 响应中未包含 __puus，可能 cookie 仍然有效");
+                        refreshPromise.complete(false);
+                    }
+                })
+                .onFailure(t -> {
+                    log.warn("UC: 刷新 __puus cookie 失败: {}", t.getMessage());
+                    refreshPromise.complete(false);
+                });
+        
+        return refreshPromise.future();
     }
 
     public Future<String> parse() {
-        var dataKey = shareLinkInfo.getShareKey();
-        var passcode =  shareLinkInfo.getSharePassword();
+        String dataKey = shareLinkInfo.getShareKey();
+        String pwd = shareLinkInfo.getShareKey();
 
+        var passcode =  (pwd == null) ? "" : pwd;
         var jsonObject = JsonObject.of("share_for_transfer", true);
         jsonObject.put("pwd_id", dataKey);
         jsonObject.put("passcode", passcode);
         // 第一次请求 获取文件信息
-        client.postAbs(FIRST_REQUEST_URL).sendJsonObject(jsonObject).onSuccess(res -> {
+        client.postAbs(FIRST_REQUEST_URL)
+                .putHeaders(header).sendJsonObject(jsonObject).onSuccess(res -> {
                     log.debug("第一阶段 {}", res.body());
                     var resJson = res.bodyAsJsonObject();
                     if (resJson.getInteger("code") != 0) {
@@ -48,6 +206,7 @@ public class UcTool extends PanBase {
                             .setTemplateParam("pwd_id", dataKey)
                             .setTemplateParam("passcode", passcode)
                             .setTemplateParam("stoken", stoken)
+                            .putHeaders(header)
                             .send().onSuccess(res2 -> {
                                 log.debug("第二阶段 {}", res2.body());
                                 JsonObject resJson2 = res2.bodyAsJsonObject();
@@ -55,24 +214,71 @@ public class UcTool extends PanBase {
                                     fail(FIRST_REQUEST_URL + " 返回异常: " + resJson2);
                                     return;
                                 }
-                                // 文件信息
-                                var info = resJson2.getJsonObject("data").getJsonArray("list").getJsonObject(0);
-                                // 第二次请求
-                                var bodyJson = JsonObject.of()
-                                        .put("fids", JsonArray.of(info.getString("fid")))
-                                        .put("pwd_id", dataKey)
-                                        .put("stoken", stoken)
-                                        .put("fids_token", JsonArray.of(info.getString("share_fid_token")));
-                                client.postAbs(THIRD_REQUEST_URL).sendJsonObject(bodyJson)
-                                        .onSuccess(res3 -> {
-                                            log.debug("第三阶段 {}", res3.body());
-                                            var resJson3 = res3.bodyAsJsonObject();
-                                            if (resJson3.getInteger("code") != 0) {
-                                                fail(FIRST_REQUEST_URL + " 返回异常: " + resJson2);
-                                                return;
-                                            }
-                                            promise.complete(resJson3.getJsonArray("data").getJsonObject(0).getString("download_url"));
-                                        }).onFailure(handleFail(THIRD_REQUEST_URL));
+                                try {
+                                    // 文件信息
+                                    JsonArray list = resJson2.getJsonObject("data").getJsonArray("list");
+                                    if (list == null || list.isEmpty()) {
+                                        fail("UC API 返回的文件列表为空");
+                                        return;
+                                    }
+                                    var info = list.getJsonObject(0);
+                                    
+                                    // 提取文件信息并保存到 otherParam
+                                    try {
+                                        FileInfo fileInfo = new FileInfo();
+                                        fileInfo.setFileId(info.getString("fid"))
+                                                .setFileName(info.getString("file_name"))
+                                                .setSize(info.getLong("size", 0L))
+                                                .setSizeStr(FileSizeConverter.convertToReadableSize(info.getLong("size", 0L)))
+                                                .setFileType(info.getBoolean("file", true) ? "file" : "folder")
+                                                .setCreateTime(DateTimeUtils.formatTimestampToDateTime(info.getString("created_at")))
+                                                .setUpdateTime(DateTimeUtils.formatTimestampToDateTime(info.getString("updated_at")))
+                                                .setPanType(shareLinkInfo.getType());
+                                        
+                                        // 保存到 otherParam，供 CacheServiceImpl 使用
+                                        shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
+                                        log.debug("UC 提取文件信息: {}", fileInfo.getFileName());
+                                    } catch (Exception e) {
+                                        log.warn("UC 提取文件信息失败，继续解析: {}", e.getMessage());
+                                    }
+                                    
+                                    // 第三次请求获取下载链接
+                                    var bodyJson = JsonObject.of()
+                                            .put("fids", JsonArray.of(info.getString("fid")))
+                                            .put("pwd_id", dataKey)
+                                            .put("stoken", stoken)
+                                            .put("fids_token", JsonArray.of(info.getString("share_fid_token")));
+                                    client.postAbs(THIRD_REQUEST_URL)
+                                            .putHeaders(header)
+                                            .sendJsonObject(bodyJson)
+                                            .onSuccess(res3 -> {
+                                                log.debug("第三阶段 {}", res3.body());
+                                                var resJson3 = res3.bodyAsJsonObject();
+                                                if (resJson3.getInteger("code") != 0) {
+                                                    fail(FIRST_REQUEST_URL + " 返回异常: " + resJson2);
+                                                    return;
+                                                }
+                                                try {
+                                                    JsonArray dataList = resJson3.getJsonArray("data");
+                                                    if (dataList == null || dataList.isEmpty()) {
+                                                        fail("UC API 返回的下载链接列表为空");
+                                                        return;
+                                                    }
+                                                    String downloadUrl = dataList.getJsonObject(0).getString("download_url");
+                                                    // UC网盘需要配合aria2下载，保存下载请求头
+                                                    Map<String, String> downloadHeaders = new HashMap<>();
+                                                    // 将header转换为Map 只需要包含cookie,user-agent,referer
+                                                    downloadHeaders.put(HttpHeaders.COOKIE.toString(), header.get(HttpHeaders.COOKIE));
+                                                    downloadHeaders.put(HttpHeaders.USER_AGENT.toString(), header.get(HttpHeaders.USER_AGENT));
+                                                    downloadHeaders.put(HttpHeaders.REFERER.toString(), "https://fast.uc.cn/");
+                                                    completeWithMeta(downloadUrl, downloadHeaders);
+                                                } catch (Exception e) {
+                                                    fail("解析 UC 下载链接失败: " + e.getMessage());
+                                                }
+                                            }).onFailure(handleFail(THIRD_REQUEST_URL));
+                                } catch (Exception e) {
+                                    fail("解析 UC 文件信息失败: " + e.getMessage());
+                                }
 
                             }).onFailure(handleFail(SECOND_REQUEST_URL));
                 }
@@ -80,43 +286,288 @@ public class UcTool extends PanBase {
         return promise.future();
     }
 
-    public static void main(String[] args) {
+    // 目录解析
+    @Override
+    public Future<List<FileInfo>> parseFileList() {
+        Promise<List<FileInfo>> promise = Promise.promise();
         
-        // https://dl-uf-zb.pds.uc.cn/l3PNAKfz/64623447/
-        // 646b0de6e9f13000c9b14ba182b805312795a82a/
-        // 646b0de6717e1bfa5bb44dd2a456f103c5177850?
-        // Expires=1737784900&OSSAccessKeyId=LTAI5tJJpWQEfrcKHnd1LqsZ&
-        // Signature=oBVV3anhv3tBKanHUcEIsktkB%2BM%3D&x-oss-traffic-limit=503316480
-        // &response-content-disposition=attachment%3B%20filename%3DC%2523%2520Shell%2520%2528C%2523%2520Offline%2520Compiler%2529_2.5.16.apks
-        // %3Bfilename%2A%3Dutf-8%27%27C%2523%2520Shell%2520%2528C%2523%2520Offline%2520Compiler%2529_2.5.16.apks
+        String pwdId = shareLinkInfo.getShareKey();
+        String passcode = shareLinkInfo.getSharePassword();
+        final String finalPasscode = (passcode == null) ? "" : passcode;
         
-        //eyJ4OmF1IjoiLSIsIng6dWQiOiI0LU4tNS0wLTYtTi0zLWZ0LTAtMi1OLU4iLCJ4OnNwIjoiMTAwIiwieDp0b2tlbiI6IjQtZjY0ZmMxMDFjZmQxZGVkNTRkMGM0NmMzYzliMzkyOWYtNS03LTE1MzYxMS1kYWNiMzY2NWJiYWE0ZjVlOWQzNzgwMGVjNjQwMzE2MC0wLTAtMC0wLTQ5YzUzNTE3OGIxOTY0YzhjYzUwYzRlMDk5MTZmYWRhIiwieDp0dGwiOiIxMDgwMCJ9
-        //eyJjYWxsYmFja0JvZHlUeXBlIjoiYXBwbGljYXRpb24vanNvbiIsImNhbGxiYWNrU3RhZ2UiOiJiZWZvcmUtZXhlY3V0ZSIsImNhbGxiYWNrRmFpbHVyZUFjdGlvbiI6Imlnbm9yZSIsImNhbGxiYWNrVXJsIjoiaHR0cHM6Ly9hdXRoLWNkbi51Yy5jbi9vdXRlci9vc3MvY2hlY2twbGF5IiwiY2FsbGJhY2tCb2R5Ijoie1wiaG9zdFwiOiR7aHR0cEhlYWRlci5ob3N0fSxcInNpemVcIjoke3NpemV9LFwicmFuZ2VcIjoke2h0dHBIZWFkZXIucmFuZ2V9LFwicmVmZXJlclwiOiR7aHR0cEhlYWRlci5yZWZlcmVyfSxcImNvb2tpZVwiOiR7aHR0cEhlYWRlci5jb29raWV9LFwibWV0aG9kXCI6JHtodHRwSGVhZGVyLm1ldGhvZH0sXCJpcFwiOiR7Y2xpZW50SXB9LFwicG9ydFwiOiR7Y2xpZW50UG9ydH0sXCJvYmplY3RcIjoke29iamVjdH0sXCJzcFwiOiR7eDpzcH0sXCJ1ZFwiOiR7eDp1ZH0sXCJ0b2tlblwiOiR7eDp0b2tlbn0sXCJhdVwiOiR7eDphdX0sXCJ0dGxcIjoke3g6dHRsfSxcImR0X3NwXCI6JHt4OmR0X3NwfSxcImhzcFwiOiR7eDpoc3B9LFwiY2xpZW50X3Rva2VuXCI6JHtxdWVyeVN0cmluZy5jbGllbnRfdG9rZW59fSJ9
-        //callback-var {"x:au":"-","x:ud":"4-N-5-0-6-N-3-ft-0-2-N-N","x:sp":"100","x:token":"4-f64fc101cfd1ded54d0c46c3c9b3929f-5-7-153611-dacb3665bbaa4f5e9d37800ec6403160-0-0-0-0-49c535178b1964c8cc50c4e09916fada","x:ttl":"10800"}
-        //callback {"callbackBodyType":"application/json","callbackStage":"before-execute","callbackFailureAction":"ignore","callbackUrl":"https://auth-cdn.uc.cn/outer/oss/checkplay","callbackBody":"{\"host\":${httpHeader.host},\"size\":${size},\"range\":${httpHeader.range},\"referer\":${httpHeader.referer},\"cookie\":${httpHeader.cookie},\"method\":${httpHeader.method},\"ip\":${clientIp},\"port\":${clientPort},\"object\":${object},\"sp\":${x:sp},\"ud\":${x:ud},\"token\":${x:token},\"au\":${x:au},\"ttl\":${x:ttl},\"dt_sp\":${x:dt_sp},\"hsp\":${x:hsp},\"client_token\":${queryString.client_token}}"}
+        // 如果参数里的目录ID不为空，则直接解析目录
+        String dirId = (String) shareLinkInfo.getOtherParam().get("dirId");
+        if (dirId != null && !dirId.isEmpty()) {
+            String stoken = (String) shareLinkInfo.getOtherParam().get("stoken");
+            if (stoken != null) {
+                parseDir(dirId, pwdId, finalPasscode, stoken, promise);
+                return promise.future();
+            }
+        }
         
-        /*
-        // callback-var
-{
-  "x:au": "-",
-  "x:ud": "4-N-5-0-6-N-3-ft-0-2-N-N",
-  "x:sp": "100",
-  "x:token": "4-f64fc101cfd1ded54d0c46c3c9b3929f-5-7-153611-dacb3665bbaa4f5e9d37800ec6403160-0-0-0-0-49c535178b1964c8cc50c4e09916fada",
-  "x:ttl": "10800"
-}
+        // 第一步：获取 stoken
+        JsonObject tokenRequest = JsonObject.of("share_for_transfer", true)
+                .put("pwd_id", pwdId)
+                .put("passcode", finalPasscode);
         
-// callback
-{
-  "callbackBodyType": "application/json",
-  "callbackStage": "before-execute",
-  "callbackFailureAction": "ignore",
-  "callbackUrl": "https://auth-cdn.uc.cn/outer/oss/checkplay",
-  "callbackBody": "{\"host\":${httpHeader.host},\"size\":${size},\"range\":${httpHeader.range},\"referer\":${httpHeader.referer},\"cookie\":${httpHeader.cookie},\"method\":${httpHeader.method},\"ip\":${clientIp},\"port\":${clientPort},\"object\":${object},\"sp\":${x:sp},\"ud\":${x:ud},\"token\":${x:token},\"au\":${x:au},\"ttl\":${x:ttl},\"dt_sp\":${x:dt_sp},\"hsp\":${x:hsp},\"client_token\":${queryString.client_token}}"
-}
-         */
+        client.postAbs(FIRST_REQUEST_URL)
+                .putHeaders(header)
+                .sendJsonObject(tokenRequest)
+                .onSuccess(res -> {
+                    JsonObject resJson = res.bodyAsJsonObject();
+                    if (resJson.getInteger("code") != 0) {
+                        promise.fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
+                        return;
+                    }
+                    String stoken = resJson.getJsonObject("data").getString("stoken");
+                    if (stoken == null || stoken.isEmpty()) {
+                        promise.fail("无法获取分享 token");
+                        return;
+                    }
+                    // 解析根目录（dirId = "0" 或空）
+                    String rootDirId = dirId != null ? dirId : "0";
+                    parseDir(rootDirId, pwdId, finalPasscode, stoken, promise);
+                })
+                .onFailure(t -> promise.fail("获取 token 失败: " + t.getMessage()));
         
-        new UcTool(ShareLinkInfo.newBuilder().shareUrl("https://fast.uc.cn/s/33197dd53ace4").shareKey("33197dd53ace4").build()).parse().onSuccess(
-                System.out::println
-        );
+        return promise.future();
     }
+
+    private void parseDir(String dirId, String pwdId, String passcode, String stoken, Promise<List<FileInfo>> promise) {
+        // 第二步：获取文件列表
+        // UC API 使用 pdir_fid 参数指定父目录 ID，根目录为 "0"
+        log.info("UC parseDir 开始: dirId={}, pwdId={}, stoken={}", dirId, pwdId, stoken);
+        
+        client.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+                .setTemplateParam("pwd_id", pwdId)
+                .setTemplateParam("passcode", passcode)
+                .setTemplateParam("stoken", stoken)
+                .addQueryParam("entry", "ft")
+                .addQueryParam("pdir_fid", dirId != null ? dirId : "0")  // 关键参数：父目录 ID
+                .addQueryParam("fetch_file_list", "1")
+                .addQueryParam("_page", "1")
+                .addQueryParam("_size", "50")
+                .addQueryParam("_fetch_total", "1")
+                .addQueryParam("_fetch_share", "1")
+                .addQueryParam("_sort", "file_type:asc,file_name:asc")
+                .addQueryParam("fr", "pc")
+                .addQueryParam("pr", "UCBrowser")
+                .putHeaders(header)
+                .send()
+                .onSuccess(res -> {
+                    JsonObject resJson = res.bodyAsJsonObject();
+                    Integer code = resJson.getInteger("code");
+                    String message = resJson.getString("message");
+                    // 如果 stoken 失效（code=14001 或错误消息包含"token"），重新获取 stoken 后重试
+                    if ((code != null && code == 14001) || 
+                        (message != null && (message.contains("token") || message.contains("Token") || message.contains("非法token")))) {
+                        log.debug("stoken 已失效，重新获取: {}", resJson);
+                        // 重新获取 stoken
+                        JsonObject tokenRequest = JsonObject.of("share_for_transfer", true)
+                                .put("pwd_id", pwdId)
+                                .put("passcode", passcode);
+                        client.postAbs(FIRST_REQUEST_URL)
+                                .putHeaders(header)
+                                .sendJsonObject(tokenRequest)
+                                .onSuccess(res2 -> {
+                                    JsonObject resJson2 = res2.bodyAsJsonObject();
+                                    if (resJson2.getInteger("code") != 0) {
+                                        promise.fail(FIRST_REQUEST_URL + " 返回异常: " + resJson2);
+                                        return;
+                                    }
+                                    String newStoken = resJson2.getJsonObject("data").getString("stoken");
+                                    if (newStoken == null || newStoken.isEmpty()) {
+                                        promise.fail("无法获取分享 token");
+                                        return;
+                                    }
+                                    // 使用新的 stoken 重试
+                                    parseDir(dirId, pwdId, passcode, newStoken, promise);
+                                })
+                                .onFailure(t -> promise.fail("重新获取 token 失败: " + t.getMessage()));
+                        return;
+                    }
+                    if (resJson.getInteger("code") != 0) {
+                        promise.fail(SECOND_REQUEST_URL + " 返回异常: " + resJson);
+                        return;
+                    }
+                    
+                    JsonArray fileList = resJson.getJsonObject("data").getJsonArray("list");
+                    if (fileList == null || fileList.isEmpty()) {
+                        log.warn("UC API 返回的文件列表为空，dirId: {}, response: {}", dirId, resJson.encodePrettily());
+                        promise.complete(new ArrayList<>());
+                        return;
+                    }
+                    
+                    log.info("UC API 返回文件列表，总数: {}, dirId: {}", fileList.size(), dirId);
+                    List<FileInfo> result = new ArrayList<>();
+                    for (int i = 0; i < fileList.size(); i++) {
+                        JsonObject item = fileList.getJsonObject(i);
+                        FileInfo fileInfo = new FileInfo();
+                        
+                        // 调试：打印前3个 item 的完整结构，方便排查字段名
+                        if (i < 3) {
+                            log.info("UC API 返回的 item[{}] 结构: {}", i, item.encodePrettily());
+                            log.info("UC API item[{}] 所有字段名: {}", i, item.fieldNames());
+                        }
+                        
+                        String fid = item.getString("fid");
+                        // UC API 可能使用 file_name 或 name，优先尝试 file_name
+                        String fileName = item.getString("file_name");
+                        if (fileName == null || fileName.isEmpty()) {
+                            fileName = item.getString("name");
+                        }
+                        // 如果还是为空，尝试其他可能的字段名
+                        if (fileName == null || fileName.isEmpty()) {
+                            fileName = item.getString("fileName");
+                        }
+                        if (fileName == null || fileName.isEmpty()) {
+                            fileName = item.getString("title");
+                        }
+                        
+                        // 如果文件名仍为空，记录警告
+                        if (fileName == null || fileName.isEmpty()) {
+                            log.warn("UC API 返回的 item 中未找到文件名字段，item: {}", item.encode());
+                        }
+                        Boolean isFile = item.getBoolean("file", true);
+                        Long fileSize = item.getLong("size", 0L);
+                        String updatedAt = item.getString("updated_at");
+                        String shareFidToken = item.getString("share_fid_token");
+                        String parentId = item.getString("parent_id");
+                        
+                        // 临时移除过滤逻辑，查看 API 实际返回数据
+                        log.info("准备处理 item[{}]: fid={}, fileName={}, parentId={}, dirId={}, isFile={}", i, fid, fileName, parentId, dirId, isFile);
+                        
+                        // 如果当前项的 fid 等于请求的 dirId，说明是当前目录本身，跳过
+                        if (fid != null && fid.equals(dirId) && !"0".equals(dirId)) {
+                            log.info("跳过当前目录本身: fid={}, dirId={}, fileName={}", fid, dirId, fileName);
+                            continue;
+                        }
+                        
+                        // UC API 可能不支持目录参数，返回所有文件
+                        // 暂时不过滤，返回所有文件，查看实际数据
+                        log.info("添加文件到结果[{}]: fid={}, fileName={}, parentId={}, dirId={}, isFile={}", i, fid, fileName, parentId, dirId, isFile);
+                        
+                        fileInfo.setFileId(fid)
+                                .setFileName(fileName)
+                                .setSize(fileSize)
+                                .setSizeStr(FileSizeConverter.convertToReadableSize(fileSize))
+                                .setCreateTime(DateTimeUtils.formatTimestampToDateTime(updatedAt))
+                                .setUpdateTime(DateTimeUtils.formatTimestampToDateTime(updatedAt))
+                                .setPanType(shareLinkInfo.getType());
+                        
+                        if (isFile) {
+                            // 文件
+                            fileInfo.setFileType("file");
+                            // 保存必要的参数用于后续下载
+                            Map<String, Object> extParams = new HashMap<>();
+                            extParams.put("fid", fid);
+                            extParams.put("pwd_id", pwdId);
+                            extParams.put("stoken", stoken);
+                            if (shareFidToken != null) {
+                                extParams.put("share_fid_token", shareFidToken);
+                            }
+                            fileInfo.setExtParameters(extParams);
+                            // 设置解析URL（用于下载）
+                            JsonObject paramJson = new JsonObject(extParams);
+                            String param = CommonUtils.urlBase64Encode(paramJson.encode());
+                            fileInfo.setParserUrl(String.format("%s/v2/redirectUrl/%s/%s", 
+                                    getDomainName(), shareLinkInfo.getType(), param));
+                        } else {
+                            // 文件夹
+                            fileInfo.setFileType("folder");
+                            fileInfo.setSize(0L);
+                            fileInfo.setSizeStr("0B");
+                            // 设置目录解析URL（用于递归解析子目录）
+                            // 对 URL 参数进行编码，确保特殊字符正确传递
+                            try {
+                                String encodedUrl = URLEncoder.encode(shareLinkInfo.getShareUrl(), StandardCharsets.UTF_8.toString());
+                                String encodedDirId = URLEncoder.encode(fid, StandardCharsets.UTF_8.toString());
+                                String encodedStoken = URLEncoder.encode(stoken, StandardCharsets.UTF_8.toString());
+                                fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s&stoken=%s", 
+                                        getDomainName(), encodedUrl, encodedDirId, encodedStoken));
+                            } catch (Exception e) {
+                                // 如果编码失败，使用原始值
+                                fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s&stoken=%s", 
+                                        getDomainName(), shareLinkInfo.getShareUrl(), fid, stoken));
+                            }
+                        }
+                        
+                        result.add(fileInfo);
+                    }
+                    
+                    promise.complete(result);
+                })
+                .onFailure(t -> promise.fail("解析目录失败: " + t.getMessage()));
+    }
+
+    @Override
+    public Future<String> parseById() {
+        Promise<String> promise = Promise.promise();
+        
+        // 从 paramJson 中提取参数
+        JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
+        if (paramJson == null) {
+            promise.fail("缺少必要的参数");
+            return promise.future();
+        }
+        
+        String fid = paramJson.getString("fid");
+        String pwdId = paramJson.getString("pwd_id");
+        String stoken = paramJson.getString("stoken");
+        String shareFidToken = paramJson.getString("share_fid_token");
+        
+        if (fid == null || pwdId == null || stoken == null) {
+            promise.fail("缺少必要的参数: fid, pwd_id 或 stoken");
+            return promise.future();
+        }
+        
+        log.debug("UC parseById: fid={}, pwd_id={}, stoken={}", fid, pwdId, stoken);
+        
+        // 调用第三次请求获取下载链接
+        JsonObject bodyJson = JsonObject.of()
+                .put("fids", JsonArray.of(fid))
+                .put("pwd_id", pwdId)
+                .put("stoken", stoken);
+        
+        if (shareFidToken != null && !shareFidToken.isEmpty()) {
+            bodyJson.put("fids_token", JsonArray.of(shareFidToken));
+        }
+        
+        client.postAbs(THIRD_REQUEST_URL)
+                .putHeaders(header)
+                .sendJsonObject(bodyJson)
+                .onSuccess(res -> {
+                    log.debug("UC parseById 响应: {}", res.body());
+                    JsonObject resJson = res.bodyAsJsonObject();
+                    if (resJson.getInteger("code") != 0) {
+                        promise.fail(THIRD_REQUEST_URL + " 返回异常: " + resJson);
+                        return;
+                    }
+                    try {
+                        JsonArray dataList = resJson.getJsonArray("data");
+                        if (dataList == null || dataList.isEmpty()) {
+                            promise.fail("UC API 返回的下载链接列表为空");
+                            return;
+                        }
+                        String downloadUrl = dataList.getJsonObject(0).getString("download_url");
+                        if (downloadUrl == null || downloadUrl.isEmpty()) {
+                            promise.fail("未找到下载链接");
+                            return;
+                        }
+                        promise.complete(downloadUrl);
+                    } catch (Exception e) {
+                        promise.fail("解析 UC 下载链接失败: " + e.getMessage());
+                    }
+                })
+                .onFailure(t -> promise.fail("请求下载链接失败: " + t.getMessage()));
+        
+        return promise.future();
+    }
+
+//    public static void main(String[] args) {
+//        // https://drive.uc.cn/s/12450d1694844?public=1
+//        new UcTool(ShareLinkInfo.newBuilder().shareKey("12450d1694844").build()).parse().onSuccess(
+//                System.out::println
+//        );
+//    }
 }

parser/src/main/java/cn/qaiu/util/CookieUtils.java

@@ -0,0 +1,185 @@
+package cn.qaiu.util;
+
+import java.util.*;
+
+/**
+ * Cookie 工具类
+ * 用于过滤和处理 Cookie 字符串
+ */
+public class CookieUtils {
+    
+    /**
+     * UC/夸克网盘常用的 Cookie 字段
+     */
+    public static final List<String> UC_QUARK_COOKIE_KEYS = Arrays.asList(
+            "__pus",   // 主要的用户会话标识(最重要)
+            "__kp",    // 用户标识
+            "__kps",   // 会话密钥
+            "__ktd",   // 会话令牌
+            "__uid",   // 用户ID
+            "__puus"   // 用户会话签名
+    );
+    
+    /**
+     * 根据指定的 key 列表过滤 cookie
+     * 
+     * @param cookieStr 原始 cookie 字符串，格式如 "key1=value1; key2=value2"
+     * @param keys 需要保留的 cookie key 列表
+     * @return 过滤后的 cookie 字符串，只包含指定的 key
+     */
+    public static String filterCookie(String cookieStr, List<String> keys) {
+        if (cookieStr == null || cookieStr.isEmpty()) {
+            return "";
+        }
+        if (keys == null || keys.isEmpty()) {
+            return cookieStr;
+        }
+        
+        // 将 keys 转为 Set 以提高查找效率
+        Set<String> keySet = new HashSet<>(keys);
+        
+        StringBuilder result = new StringBuilder();
+        String[] cookies = cookieStr.split(";\\s*");
+        
+        for (String cookie : cookies) {
+            if (cookie.isEmpty()) {
+                continue;
+            }
+            
+            // 提取 cookie 的 key
+            int equalIndex = cookie.indexOf('=');
+            if (equalIndex > 0) {
+                String key = cookie.substring(0, equalIndex).trim();
+                
+                // 如果 key 在需要的列表中，保留这个 cookie
+                if (keySet.contains(key)) {
+                    if (result.length() > 0) {
+                        result.append("; ");
+                    }
+                    result.append(cookie);
+                }
+            }
+        }
+        
+        return result.toString();
+    }
+    
+    /**
+     * 使用 UC/夸克网盘默认的 cookie 字段过滤
+     * 
+     * @param cookieStr 原始 cookie 字符串
+     * @return 过滤后的 cookie 字符串
+     */
+    public static String filterUcQuarkCookie(String cookieStr) {
+        return filterCookie(cookieStr, UC_QUARK_COOKIE_KEYS);
+    }
+    
+    /**
+     * 从 cookie 字符串中提取指定 key 的值
+     * 
+     * @param cookieStr cookie 字符串
+     * @param key 要提取的 cookie key
+     * @return cookie 值，如果不存在返回 null
+     */
+    public static String getCookieValue(String cookieStr, String key) {
+        if (cookieStr == null || cookieStr.isEmpty() || key == null) {
+            return null;
+        }
+        
+        String[] cookies = cookieStr.split(";\\s*");
+        for (String cookie : cookies) {
+            if (cookie.startsWith(key + "=")) {
+                int equalIndex = cookie.indexOf('=');
+                if (equalIndex > 0 && equalIndex < cookie.length() - 1) {
+                    return cookie.substring(equalIndex + 1);
+                }
+            }
+        }
+        
+        return null;
+    }
+    
+    /**
+     * 检查 cookie 字符串中是否包含指定的 key
+     * 
+     * @param cookieStr cookie 字符串
+     * @param key 要检查的 cookie key
+     * @return true 表示包含该 key
+     */
+    public static boolean containsKey(String cookieStr, String key) {
+        return getCookieValue(cookieStr, key) != null;
+    }
+    
+    /**
+     * 更新 cookie 字符串中的指定 cookie 值
+     * 
+     * @param cookieStr 原始 cookie 字符串
+     * @param cookieName cookie 名称
+     * @param newValue 新的完整 cookie 值（格式：cookieName=value）
+     * @return 更新后的 cookie 字符串
+     */
+    public static String updateCookieValue(String cookieStr, String cookieName, String newValue) {
+        if (cookieStr == null || cookieStr.isEmpty()) {
+            return newValue;
+        }
+        
+        StringBuilder result = new StringBuilder();
+        String[] cookies = cookieStr.split(";\\s*");
+        boolean found = false;
+        
+        for (String cookie : cookies) {
+            if (cookie.startsWith(cookieName + "=")) {
+                // 替换为新值
+                if (result.length() > 0) result.append("; ");
+                result.append(newValue);
+                found = true;
+            } else if (!cookie.isEmpty()) {
+                if (result.length() > 0) result.append("; ");
+                result.append(cookie);
+            }
+        }
+        
+        // 如果原来没有这个 cookie，添加它
+        if (!found) {
+            if (result.length() > 0) result.append("; ");
+            result.append(newValue);
+        }
+        
+        return result.toString();
+    }
+    
+    /**
+     * 合并多个 cookie 字符串，后面的会覆盖前面的同名 cookie
+     * 
+     * @param cookieStrings cookie 字符串数组
+     * @return 合并后的 cookie 字符串
+     */
+    public static String mergeCookies(String... cookieStrings) {
+        if (cookieStrings == null || cookieStrings.length == 0) {
+            return "";
+        }
+        
+        Map<String, String> cookieMap = new LinkedHashMap<>();
+        
+        for (String cookieStr : cookieStrings) {
+            if (cookieStr == null || cookieStr.isEmpty()) {
+                continue;
+            }
+            
+            String[] cookies = cookieStr.split(";\\s*");
+            for (String cookie : cookies) {
+                if (cookie.isEmpty()) {
+                    continue;
+                }
+                
+                int equalIndex = cookie.indexOf('=');
+                if (equalIndex > 0) {
+                    String key = cookie.substring(0, equalIndex).trim();
+                    cookieMap.put(key, cookie);
+                }
+            }
+        }
+        
+        return String.join("; ", cookieMap.values());
+    }
+}

parser/src/main/java/cn/qaiu/util/DateTimeUtils.java

@@ -0,0 +1,111 @@
+package cn.qaiu.util;
+
+import java.time.*;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * 日期时间工具类，用于转换各种时间戳格式为可读的日期字符串
+ */
+public class DateTimeUtils {
+
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+    
+    private static final DateTimeFormatter ISO_FORMATTER = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
+
+    /**
+     * 将毫秒时间戳转换为 yyyy-MM-dd HH:mm:ss 格式
+     * @param millis 毫秒时间戳
+     * @return 格式化后的日期字符串
+     */
+    public static String formatMillisToDateTime(long millis) {
+        return FORMATTER.format(Instant.ofEpochMilli(millis).atZone(ZoneId.systemDefault()).toLocalDateTime());
+    }
+
+    /**
+     * 将毫秒时间戳字符串转换为 yyyy-MM-dd HH:mm:ss 格式
+     * @param millisStr 毫秒时间戳字符串（如 "1684737715067"）
+     * @return 格式化后的日期字符串
+     */
+    public static String formatMillisStringToDateTime(String millisStr) {
+        if (millisStr == null || millisStr.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            long millis = Long.parseLong(millisStr.trim());
+            return formatMillisToDateTime(millis);
+        } catch (NumberFormatException e) {
+            // 如果解析失败，返回原始值
+            return millisStr;
+        }
+    }
+
+    /**
+     * 将秒级时间戳转换为 yyyy-MM-dd HH:mm:ss 格式
+     * @param seconds 秒级时间戳
+     * @return 格式化后的日期字符串
+     */
+    public static String formatSecondsToDateTime(long seconds) {
+        return FORMATTER.format(Instant.ofEpochSecond(seconds).atZone(ZoneId.systemDefault()).toLocalDateTime());
+    }
+
+    /**
+     * 将秒级时间戳字符串转换为 yyyy-MM-dd HH:mm:ss 格式
+     * @param secondsStr 秒级时间戳字符串
+     * @return 格式化后的日期字符串
+     */
+    public static String formatSecondsStringToDateTime(String secondsStr) {
+        if (secondsStr == null || secondsStr.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            long seconds = Long.parseLong(secondsStr.trim());
+            return formatSecondsToDateTime(seconds);
+        } catch (NumberFormatException e) {
+            // 如果解析失败，返回原始值
+            return secondsStr;
+        }
+    }
+
+    /**
+     * 智能转换时间戳：自动判断是毫秒还是秒级
+     * 根据值的大小判断：如果大于等于 10000000000（即 2286-11-20），视为毫秒；否则视为秒级
+     * @param timestamp 时间戳字符串
+     * @return 格式化后的日期字符串
+     */
+    public static String formatTimestampToDateTime(String timestamp) {
+        if (timestamp == null || timestamp.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            long value = Long.parseLong(timestamp.trim());
+            // 10000000000 对应 2286-11-20（毫秒）或 1970-04-26（秒级）
+            // 使用 10^10 作为分界线
+            if (value >= 10_000_000_000L) {
+                return formatMillisToDateTime(value);
+            } else {
+                return formatSecondsToDateTime(value);
+            }
+        } catch (NumberFormatException e) {
+            // 如果是 ISO 8601 格式，尝试解析
+            return formatISODateTime(timestamp);
+        }
+    }
+
+    /**
+     * 解析并格式化 ISO 8601 格式的日期时间字符串
+     * @param isoDateTime ISO 8601 格式的日期时间字符串
+     * @return 格式化后的日期字符串
+     */
+    public static String formatISODateTime(String isoDateTime) {
+        if (isoDateTime == null || isoDateTime.trim().isEmpty()) {
+            return "";
+        }
+        try {
+            OffsetDateTime offsetDateTime = OffsetDateTime.parse(isoDateTime, ISO_FORMATTER);
+            return FORMATTER.format(offsetDateTime.toLocalDateTime());
+        } catch (Exception e) {
+            // 如果格式化失败，直接返回原始值
+            return isoDateTime;
+        }
+    }
+}

parser/src/main/resources/custom-parsers/fetch-demo.js

@@ -1,105 +1,105 @@
-// ==UserScript==
-// @name         Fetch API示例解析器
-// @type         fetch_demo
-// @displayName  Fetch演示
-// @description  演示如何在ES5环境中使用fetch API和async/await
-// @match        https?://example\.com/s/(?<KEY>\w+)
-// @author       QAIU
-// @version      1.0.0
-// ==/UserScript==
+// // ==UserScript==
+// // @name         Fetch API示例解析器
+// // @type         fetch_demo
+// // @displayName  Fetch演示
+// // @description  演示如何在ES5环境中使用fetch API和async/await
+// // @match        https?://example\.com/s/(?<KEY>\w+)
+// // @author       QAIU
+// // @version      1.0.0
+// // ==/UserScript==
 
-// 使用require导入类型定义（仅用于IDE类型提示）
-var types = require('./types');
-/** @typedef {types.ShareLinkInfo} ShareLinkInfo */
-/** @typedef {types.JsHttpClient} JsHttpClient */
-/** @typedef {types.JsLogger} JsLogger */
+// // 使用require导入类型定义（仅用于IDE类型提示）
+// var types = require('./types');
+// /** @typedef {types.ShareLinkInfo} ShareLinkInfo */
+// /** @typedef {types.JsHttpClient} JsHttpClient */
+// /** @typedef {types.JsLogger} JsLogger */
 
-/**
- * 演示使用fetch API的解析器
- * 注意：虽然源码中使用了ES6+语法（async/await），但在浏览器中会被编译为ES5
- * 
- * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息
- * @param {JsHttpClient} http - HTTP客户端（传统方式）
- * @param {JsLogger} logger - 日志对象
- * @returns {string} 下载链接
- */
-function parse(shareLinkInfo, http, logger) {
-    logger.info("=== Fetch API Demo ===");
+// /**
+//  * 演示使用fetch API的解析器
+//  * 注意：虽然源码中使用了ES6+语法（async/await），但在浏览器中会被编译为ES5
+//  * 
+//  * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息
+//  * @param {JsHttpClient} http - HTTP客户端（传统方式）
+//  * @param {JsLogger} logger - 日志对象
+//  * @returns {string} 下载链接
+//  */
+// function parse(shareLinkInfo, http, logger) {
+//     logger.info("=== Fetch API Demo ===");
     
-    // 方式1：使用传统的http对象（同步）
-    logger.info("方式1: 使用传统http对象");
-    var response1 = http.get("https://httpbin.org/get");
-    logger.info("状态码: " + response1.statusCode());
+//     // 方式1：使用传统的http对象（同步）
+//     logger.info("方式1: 使用传统http对象");
+//     var response1 = http.get("https://httpbin.org/get");
+//     logger.info("状态码: " + response1.statusCode());
     
-    // 方式2：使用fetch API（基于Promise）
-    logger.info("方式2: 使用fetch API");
+//     // 方式2：使用fetch API（基于Promise）
+//     logger.info("方式2: 使用fetch API");
     
-    // 注意：在ES5环境中，我们需要手动处理Promise
-    // 这个示例展示了如何在ES5中使用fetch
-    var fetchPromise = fetch("https://httpbin.org/get");
+//     // 注意：在ES5环境中，我们需要手动处理Promise
+//     // 这个示例展示了如何在ES5中使用fetch
+//     var fetchPromise = fetch("https://httpbin.org/get");
     
-    // 等待Promise完成（同步等待模拟）
-    var result = null;
-    var error = null;
+//     // 等待Promise完成（同步等待模拟）
+//     var result = null;
+//     var error = null;
     
-    fetchPromise
-        .then(function(response) {
-            logger.info("Fetch响应状态: " + response.status);
-            return response.text();
-        })
-        .then(function(text) {
-            logger.info("Fetch响应内容: " + text.substring(0, 100) + "...");
-            result = "https://example.com/download/demo.file";
-        })
-        ['catch'](function(err) {
-            logger.error("Fetch失败: " + err.message);
-            error = err;
-        });
+//     fetchPromise
+//         .then(function(response) {
+//             logger.info("Fetch响应状态: " + response.status);
+//             return response.text();
+//         })
+//         .then(function(text) {
+//             logger.info("Fetch响应内容: " + text.substring(0, 100) + "...");
+//             result = "https://example.com/download/demo.file";
+//         })
+//         ['catch'](function(err) {
+//             logger.error("Fetch失败: " + err.message);
+//             error = err;
+//         });
     
-    // 简单的等待循环（实际场景中不推荐，这里仅作演示）
-    var timeout = 5000; // 5秒超时
-    var start = Date.now();
-    while (result === null && error === null && (Date.now() - start) < timeout) {
-        // 等待Promise完成
-        java.lang.Thread.sleep(10);
-    }
+//     // 简单的等待循环（实际场景中不推荐，这里仅作演示）
+//     var timeout = 5000; // 5秒超时
+//     var start = Date.now();
+//     while (result === null && error === null && (Date.now() - start) < timeout) {
+//         // 等待Promise完成
+//         java.lang.Thread.sleep(10);
+//     }
     
-    if (error !== null) {
-        throw error;
-    }
+//     if (error !== null) {
+//         throw error;
+//     }
     
-    if (result === null) {
-        throw new Error("Fetch超时");
-    }
+//     if (result === null) {
+//         throw new Error("Fetch超时");
+//     }
     
-    return result;
-}
+//     return result;
+// }
 
-/**
- * 演示POST请求
- */
-function demonstratePost(logger) {
-    logger.info("=== 演示POST请求 ===");
+// /**
+//  * 演示POST请求
+//  */
+// function demonstratePost(logger) {
+//     logger.info("=== 演示POST请求 ===");
     
-    var postPromise = fetch("https://httpbin.org/post", {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-            key: "value",
-            demo: true
-        })
-    });
+//     var postPromise = fetch("https://httpbin.org/post", {
+//         method: "POST",
+//         headers: {
+//             "Content-Type": "application/json"
+//         },
+//         body: JSON.stringify({
+//             key: "value",
+//             demo: true
+//         })
+//     });
     
-    postPromise
-        .then(function(response) {
-            return response.json();
-        })
-        .then(function(data) {
-            logger.info("POST响应: " + JSON.stringify(data));
-        })
-        ['catch'](function(err) {
-            logger.error("POST失败: " + err.message);
-        });
-}
+//     postPromise
+//         .then(function(response) {
+//             return response.json();
+//         })
+//         .then(function(data) {
+//             logger.info("POST响应: " + JSON.stringify(data));
+//         })
+//         ['catch'](function(err) {
+//             logger.error("POST失败: " + err.message);
+//         });
+// }

parser/src/main/resources/custom-parsers/py/example_parser.py

@@ -1,141 +0,0 @@
-# ==UserScript==
-# @name         示例Python解析器
-# @type         example_py_parser
-# @displayName  示例网盘(Python)
-# @match        https?://example\.com/s/(?P<KEY>\w+)(?:\?pwd=(?P<PWD>\w+))?
-# @description  Python解析器示例，展示如何编写Python网盘解析器
-# @author       QAIU
-# @version      1.0.0
-# ==/UserScript==
-
-"""
-Python解析器示例
-
-可用的全局对象:
-- http: HTTP客户端 (PyHttpClient)
-- logger: 日志对象 (PyLogger)
-- share_link_info: 分享信息 (PyShareLinkInfoWrapper)
-- crypto: 加密工具 (PyCryptoUtils)
-
-必须实现的函数:
-- parse(share_link_info, http, logger): 解析下载链接，返回下载URL字符串
-
-可选实现的函数:
-- parse_file_list(share_link_info, http, logger): 解析文件列表，返回文件信息列表
-- parse_by_id(share_link_info, http, logger): 根据文件ID解析下载链接
-
-注意事项:
-- http、logger、crypto 等对象已在全局注入，无需导入
-- 如需使用标准库，直接 import 即可（如：import json, import re）
-"""
-
-
-def parse(share_link_info, http, logger):
-    """
-    解析分享链接，获取直链下载地址
-    
-    参数:
-        share_link_info: 分享信息对象
-            - get_share_url(): 获取分享URL
-            - get_share_key(): 获取分享Key
-            - get_share_password(): 获取分享密码
-            - get_type(): 获取网盘类型
-        http: HTTP客户端
-            - get(url): GET请求
-            - post(url, data): POST请求
-            - put_header(name, value): 设置请求头
-            - set_timeout(seconds): 设置超时时间
-        logger: 日志对象
-            - info(msg): 信息日志
-            - debug(msg): 调试日志
-            - warn(msg): 警告日志
-            - error(msg): 错误日志
-    
-    返回:
-        str: 直链下载地址
-    """
-    # 获取分享信息
-    share_url = share_link_info.get_share_url()
-    share_key = share_link_info.get_share_key()
-    share_password = share_link_info.get_share_password()
-    
-    logger.info(f"开始解析: {share_url}")
-    logger.info(f"分享Key: {share_key}")
-    
-    # 设置请求头
-    http.put_header("Referer", share_url)
-    
-    # 发起GET请求获取页面内容
-    response = http.get(share_url)
-    
-    if not response.ok():
-        logger.error(f"请求失败: {response.status_code()}")
-        raise Exception(f"请求失败: {response.status_code()}")
-    
-    html = response.text()
-    logger.debug(f"响应长度: {len(html)}")
-    
-    # 示例：从响应中提取下载链接
-    # 实际解析逻辑根据具体网盘API实现
-    
-    # 演示使用加密工具
-    # md5_hash = crypto.md5(share_key)
-    # logger.info(f"MD5: {md5_hash}")
-    
-    # 返回模拟的下载链接
-    return f"https://example.com/download/{share_key}"
-
-
-def parse_file_list(share_link_info, http, logger):
-    """
-    解析文件列表
-    
-    返回:
-        list: 文件信息列表，每个元素是字典，包含:
-            - file_name: 文件名
-            - file_id: 文件ID
-            - file_type: 文件类型
-            - size: 文件大小(字节)
-            - pan_type: 网盘类型
-            - parser_url: 解析URL
-    """
-    share_url = share_link_info.get_share_url()
-    share_key = share_link_info.get_share_key()
-    
-    logger.info(f"获取文件列表: {share_url}")
-    
-    # 示例返回
-    return [
-        {
-            "file_name": "示例文件1.txt",
-            "file_id": "file_001",
-            "file_type": "file",
-            "size": 1024,
-            "pan_type": "example_py_parser",
-            "parser_url": f"/parser?type=example_py_parser&key={share_key}&fileId=file_001"
-        },
-        {
-            "file_name": "示例文件2.zip",
-            "file_id": "file_002",
-            "file_type": "file",
-            "size": 2048,
-            "pan_type": "example_py_parser",
-            "parser_url": f"/parser?type=example_py_parser&key={share_key}&fileId=file_002"
-        }
-    ]
-
-
-def parse_by_id(share_link_info, http, logger):
-    """
-    根据文件ID解析下载链接
-    
-    返回:
-        str: 直链下载地址
-    """
-    file_id = share_link_info.get_other_param("fileId")
-    share_key = share_link_info.get_share_key()
-    
-    logger.info(f"按ID解析: fileId={file_id}, shareKey={share_key}")
-    
-    # 返回模拟的下载链接
-    return f"https://example.com/download/{share_key}/{file_id}"