Fixed 蓝奏云目录解析cookie验证问题

Removed unused Java launch configurations from launch.json.

.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 package -DskipTests
+    - name: 编译项目
+      run: ./mvnw clean compile
+      
+#    - 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

@@ -80,7 +80,3 @@ yarn-error.log*
 *.iml
 *.ipr
 *.iws
-
-# GraalPy pip packages (local installation)
-parser/src/main/resources/graalpy-packages/
-**/graalpy-packages/

.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,4 @@
 {
     "java.compile.nullAnalysis.mode": "automatic",
-    "java.configuration.updateBuildConfiguration": "automatic"
+    "java.configuration.updateBuildConfiguration": "interactive"
 }

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

@@ -5,7 +5,7 @@
 <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.22-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>
 </p>
@@ -14,12 +14,7 @@
 
 
 # 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` 标签
+QQ交流群：1017480890
 
 netdisk-fast-download网盘直链云解析(nfd云解析)能把网盘分享下载链接转化为直链，支持多款云盘，已支持蓝奏云/蓝奏云优享/奶牛快传/移动云云空间/小飞机盘/亿方云/123云盘/Cloudreve等，支持加密分享，以及部分网盘文件夹分享。  
 
@@ -45,34 +40,12 @@ 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）
-
-在线编写、测试和发布解析器脚本，支持 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`（需要密码或配置公开访问）
+**Playground功能：** [JS解析器演练场密码保护说明](PLAYGROUND_PASSWORD_PROTECTION.md)
 
 ## 预览地址  
 [预览地址1](https://lz.qaiu.top)  
 [预览地址2](https://lz0.qaiu.top)  
-[移动/联通/天翼云盘大文件试用版](https://189.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返回数据格式示例**  
@@ -121,6 +94,8 @@ main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/
 - [天翼云盘-p189](https://cloud.189.cn/)
 
 ## API接口
+
+[api接口文档](https://nfdparser.apifox.cn/)
   
 ### 服务端口
 - **6400**: API 服务端口（建议使用 Nginx 代理）
@@ -318,51 +293,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 +307,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

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/src/main/java/cn/qaiu/vx/core/handlerfactory/RouterHandlerFactory.java

@@ -69,112 +69,14 @@ 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();
-            
+            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());
@@ -196,24 +98,21 @@ 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 路径
+        // 30天过期时间（毫秒）
         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);
+        mainRouter.route().handler(sessionHandler);
 
-        // 拦截器 - 排除 WebSocket 路径
+        // 拦截器
         Set<Handler<RoutingContext>> interceptorSet = getInterceptorSet();
-        Route route0 = mainRouter.routeWithRegex("^(?!/v2/ws/).*");
+        Route route0 = mainRouter.route("/*");
         interceptorSet.forEach(route0::handler);
 
         try {
@@ -297,9 +196,27 @@ public class RouterHandlerFactory implements BaseHttpApi {
                     }
                 });
             } 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);
             }
         }
     }

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/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/pom.xml

@@ -59,7 +59,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
         <!-- Versions -->
-        <vertx.version>4.5.23</vertx.version>
+        <vertx.version>4.5.22</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>
@@ -67,14 +67,6 @@
         <jackson.version>2.14.2</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/PanDomainTemplate.java

@@ -104,7 +104,7 @@ public enum PanDomainTemplate {
                       "lanzoug|" +
                       "lanzoum" +
                      ")\\.com/(.+/)?(?<KEY>.+)"),
-            "https://lanzoux.com/{shareKey}",
+            "https://w1.lanzn.com/{shareKey}",
             LzTool.class),
 
     // https://www.feijix.com/s/

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/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/IzTool.java

@@ -4,13 +4,15 @@ 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.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.json.JsonArray;
 import io.vertx.core.json.JsonObject;
+import io.vertx.ext.web.client.WebClientSession;
 import io.vertx.uritemplate.UriTemplate;
 import org.apache.commons.lang3.StringUtils;
 
@@ -18,10 +20,12 @@ import java.util.*;
 
 /**
  * 蓝奏云优享
- *
+ * v019b22
  */
 public class IzTool extends PanBase {
 
+    WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
+
     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" +
@@ -70,6 +74,19 @@ public class IzTool extends PanBase {
         super(shareLinkInfo);
     }
 
+    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);
+    }
+
     public Future<String> parse() {
         String shareId = shareLinkInfo.getShareKey();
 
@@ -80,70 +97,100 @@ public class IzTool extends PanBase {
         // 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))
+        webClientSession.postAbs(UriTemplate.of(VIP_REQUEST_URL))
                 .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))
+                    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);
+                                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 -> {
+                                                handleParseResponse(asText(res2), shareId);
+                                            }).onFailure(handleFail(FIRST_REQUEST_URL));
                                     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());
-                                    return;
-                                }
-
-                                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));
+                                handleParseResponse(resBody, shareId);
                             }).onFailure(handleFail(FIRST_REQUEST_URL));
                 });
         return promise.future();
     }
 
+    private void handleParseResponse(String resBody, String shareId) {
+        JsonObject resJson;
+        try {
+            resJson = new JsonObject(resBody);
+        } catch (Exception e) {
+            fail(FIRST_REQUEST_URL + " 解析JSON失败: " + resBody);
+            return;
+        }
+        if (resJson.isEmpty()) {
+            fail(FIRST_REQUEST_URL + " 返回内容为空");
+            return;
+        }
+        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());
+            return;
+        }
+
+        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);
+        // 第二次请求
+        webClientSession.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));
+    }
+
     @Override
     public Future<List<FileInfo>> parseFileList() {
         Promise<List<FileInfo>> promise = Promise.promise();
@@ -174,7 +221,7 @@ public class IzTool extends PanBase {
         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)
@@ -264,7 +311,7 @@ public class IzTool extends PanBase {
     public Future<String> parseById() {
         // 第二次请求
         JsonObject paramJson = (JsonObject)shareLinkInfo.getOtherParam().get("paramJson");
-        clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
+        webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
                 .setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
                 .setTemplateParam("uuid", paramJson.getString("uuid"))
                 .setTemplateParam("ts", paramJson.getString("ts"))

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,100 @@ 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);
+                        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) {
+        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);
+                // Matcher matcher2 = Pattern.compile("'sign'\s*:\s*'(\\w+)'").matcher(html2);
+                String jsText = getJsText(html2);
+                if (jsText == null) {
+                    headers0.add("Referer", absoluteURI);
+                    setCookie(html2);
+                    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, 可能分享已失效");
+                            return;
+                        }
+                    });
+                } 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 html2) {
+        int beginIndex = html2.indexOf("arg1='") + 6;
+        String arg1 = html2.substring(beginIndex, html2.indexOf("';", beginIndex));
+        String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
+        // 创建一个 Cookie 并放入 CookieStore
+        DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
+        nettyCookie.setDomain(".lanzn.com"); // 设置域名
+        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 +177,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 +209,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");
@@ -178,7 +224,6 @@ public class LzTool extends PanBase {
 
                 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");
@@ -195,12 +240,13 @@ public class LzTool extends PanBase {
                                 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 +294,98 @@ public class LzTool extends PanBase {
         String sUrl = shareLinkInfo.getShareUrl();
         String pwd = shareLinkInfo.getSharePassword();
 
-        WebClient client = clientNoRedirects;
-        client.getAbs(sUrl).send().onSuccess(res -> {
+        webClientSession.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);
+            // 检查是否需要 cookie 验证
+            if (html.contains("var arg1='")) {
+                webClientSession = WebClientSession.create(clientNoRedirects);
+                setCookie(html);
+                // 重新请求
+                webClientSession.getAbs(sUrl).send().onSuccess(res2 -> {
+                    handleFileListParse(res2.bodyAsString(), 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) {
+        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);
+                    // 重新请求
+                    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 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");
+                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 (Exception e) {
+            promise.fail(e);
+        }
+    }
+
     void setFileInfo(String html, ShareLinkInfo shareLinkInfo) {
         // 写入 fileInfo
         FileInfo fileInfo = new FileInfo();

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}"

parser/src/main/resources/py/types.pyi

@@ -1,339 +0,0 @@
-"""
-NFD Python解析器类型存根文件
-提供IDE自动补全和类型检查支持
-"""
-
-from typing import Dict, List, Optional, Any
-
-
-class PyShareLinkInfoWrapper:
-    """分享链接信息包装器"""
-    
-    def get_share_url(self) -> str:
-        """获取分享URL"""
-        ...
-    
-    def get_share_key(self) -> str:
-        """获取分享Key"""
-        ...
-    
-    def get_share_password(self) -> Optional[str]:
-        """获取分享密码"""
-        ...
-    
-    def get_type(self) -> str:
-        """获取网盘类型"""
-        ...
-    
-    def get_pan_name(self) -> str:
-        """获取网盘名称"""
-        ...
-    
-    def get_other_param(self, key: str) -> Optional[Any]:
-        """获取其他参数"""
-        ...
-    
-    def get_all_other_params(self) -> Dict[str, Any]:
-        """获取所有其他参数"""
-        ...
-    
-    def has_other_param(self, key: str) -> bool:
-        """检查是否包含指定参数"""
-        ...
-    
-    def get_other_param_as_string(self, key: str) -> Optional[str]:
-        """获取其他参数的字符串值"""
-        ...
-    
-    def get_other_param_as_integer(self, key: str) -> Optional[int]:
-        """获取其他参数的整数值"""
-        ...
-    
-    def get_other_param_as_boolean(self, key: str) -> Optional[bool]:
-        """获取其他参数的布尔值"""
-        ...
-
-
-class PyHttpResponse:
-    """HTTP响应封装"""
-    
-    def text(self) -> str:
-        """获取响应体文本"""
-        ...
-    
-    def body(self) -> str:
-        """获取响应体文本（别名）"""
-        ...
-    
-    def json(self) -> Optional[Dict[str, Any]]:
-        """解析JSON响应"""
-        ...
-    
-    def status_code(self) -> int:
-        """获取HTTP状态码"""
-        ...
-    
-    def header(self, name: str) -> Optional[str]:
-        """获取响应头"""
-        ...
-    
-    def headers(self) -> Dict[str, str]:
-        """获取所有响应头"""
-        ...
-    
-    def ok(self) -> bool:
-        """检查请求是否成功（2xx状态码）"""
-        ...
-    
-    def content(self) -> bytes:
-        """获取响应体字节数组"""
-        ...
-    
-    def content_length(self) -> int:
-        """获取响应体大小"""
-        ...
-
-
-class PyHttpClient:
-    """HTTP客户端"""
-    
-    def get(self, url: str) -> PyHttpResponse:
-        """发起GET请求"""
-        ...
-    
-    def get_with_redirect(self, url: str) -> PyHttpResponse:
-        """发起GET请求并跟随重定向"""
-        ...
-    
-    def get_no_redirect(self, url: str) -> PyHttpResponse:
-        """发起GET请求但不跟随重定向"""
-        ...
-    
-    def post(self, url: str, data: Any = None) -> PyHttpResponse:
-        """发起POST请求"""
-        ...
-    
-    def post_json(self, url: str, json_data: Any = None) -> PyHttpResponse:
-        """发起POST请求（JSON数据）"""
-        ...
-    
-    def put(self, url: str, data: Any = None) -> PyHttpResponse:
-        """发起PUT请求"""
-        ...
-    
-    def delete(self, url: str) -> PyHttpResponse:
-        """发起DELETE请求"""
-        ...
-    
-    def patch(self, url: str, data: Any = None) -> PyHttpResponse:
-        """发起PATCH请求"""
-        ...
-    
-    def put_header(self, name: str, value: str) -> 'PyHttpClient':
-        """设置请求头"""
-        ...
-    
-    def put_headers(self, headers: Dict[str, str]) -> 'PyHttpClient':
-        """批量设置请求头"""
-        ...
-    
-    def remove_header(self, name: str) -> 'PyHttpClient':
-        """删除指定请求头"""
-        ...
-    
-    def clear_headers(self) -> 'PyHttpClient':
-        """清空所有请求头"""
-        ...
-    
-    def get_headers(self) -> Dict[str, str]:
-        """获取所有请求头"""
-        ...
-    
-    def set_timeout(self, seconds: int) -> 'PyHttpClient':
-        """设置请求超时时间"""
-        ...
-    
-    @staticmethod
-    def url_encode(string: str) -> str:
-        """URL编码"""
-        ...
-    
-    @staticmethod
-    def url_decode(string: str) -> str:
-        """URL解码"""
-        ...
-
-
-class PyLogger:
-    """日志记录器"""
-    
-    def debug(self, message: str, *args) -> None:
-        """调试日志"""
-        ...
-    
-    def info(self, message: str, *args) -> None:
-        """信息日志"""
-        ...
-    
-    def warn(self, message: str, *args) -> None:
-        """警告日志"""
-        ...
-    
-    def error(self, message: str, *args) -> None:
-        """错误日志"""
-        ...
-    
-    def is_debug_enabled(self) -> bool:
-        """检查是否启用调试级别日志"""
-        ...
-    
-    def is_info_enabled(self) -> bool:
-        """检查是否启用信息级别日志"""
-        ...
-
-
-class PyCryptoUtils:
-    """加密工具类"""
-    
-    def md5(self, data: str) -> str:
-        """MD5加密（32位小写）"""
-        ...
-    
-    def md5_16(self, data: str) -> str:
-        """MD5加密（16位小写）"""
-        ...
-    
-    def sha1(self, data: str) -> str:
-        """SHA-1加密"""
-        ...
-    
-    def sha256(self, data: str) -> str:
-        """SHA-256加密"""
-        ...
-    
-    def sha512(self, data: str) -> str:
-        """SHA-512加密"""
-        ...
-    
-    def base64_encode(self, data: str) -> str:
-        """Base64编码"""
-        ...
-    
-    def base64_encode_bytes(self, data: bytes) -> str:
-        """Base64编码（字节数组）"""
-        ...
-    
-    def base64_decode(self, data: str) -> str:
-        """Base64解码"""
-        ...
-    
-    def base64_decode_bytes(self, data: str) -> bytes:
-        """Base64解码（返回字节数组）"""
-        ...
-    
-    def base64_url_encode(self, data: str) -> str:
-        """URL安全的Base64编码"""
-        ...
-    
-    def base64_url_decode(self, data: str) -> str:
-        """URL安全的Base64解码"""
-        ...
-    
-    def aes_encrypt_ecb(self, data: str, key: str) -> str:
-        """AES加密（ECB模式）"""
-        ...
-    
-    def aes_decrypt_ecb(self, data: str, key: str) -> str:
-        """AES解密（ECB模式）"""
-        ...
-    
-    def aes_encrypt_cbc(self, data: str, key: str, iv: str) -> str:
-        """AES加密（CBC模式）"""
-        ...
-    
-    def aes_decrypt_cbc(self, data: str, key: str, iv: str) -> str:
-        """AES解密（CBC模式）"""
-        ...
-    
-    def bytes_to_hex(self, data: bytes) -> str:
-        """字节数组转十六进制"""
-        ...
-    
-    def hex_to_bytes(self, hex_string: str) -> bytes:
-        """十六进制转字节数组"""
-        ...
-
-
-# 全局变量类型声明
-http: PyHttpClient
-logger: PyLogger
-share_link_info: PyShareLinkInfoWrapper
-crypto: PyCryptoUtils
-
-
-class FileInfo:
-    """文件信息"""
-    file_name: str
-    file_id: str
-    file_type: str
-    size: int
-    size_str: str
-    create_time: str
-    update_time: str
-    create_by: str
-    download_count: int
-    file_icon: str
-    pan_type: str
-    parser_url: str
-    preview_url: str
-
-
-def parse(share_link_info: PyShareLinkInfoWrapper, http: PyHttpClient, logger: PyLogger) -> str:
-    """
-    解析分享链接，获取直链下载地址
-    
-    这是必须实现的主要解析函数
-    
-    Args:
-        share_link_info: 分享链接信息
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        直链下载地址
-    """
-    ...
-
-
-def parse_file_list(share_link_info: PyShareLinkInfoWrapper, http: PyHttpClient, logger: PyLogger) -> List[Dict[str, Any]]:
-    """
-    解析文件列表
-    
-    可选实现，用于支持目录分享
-    
-    Args:
-        share_link_info: 分享链接信息
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        文件信息列表
-    """
-    ...
-
-
-def parse_by_id(share_link_info: PyShareLinkInfoWrapper, http: PyHttpClient, logger: PyLogger) -> str:
-    """
-    根据文件ID解析下载链接
-    
-    可选实现，用于支持按文件ID解析
-    
-    Args:
-        share_link_info: 分享链接信息
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        直链下载地址
-    """
-    ...

parser/src/main/resources/requests_guard.py

@@ -1,310 +0,0 @@
-"""
-requests_guard.py - 网络请求安全卫士
-对 requests, urllib 等网络库做猴子补丁，阻断本地及危险地址的访问
-用法：在程序最早 import 本模块即可全局生效
-
-功能：
-1. 拦截 requests 库的所有 HTTP 请求
-2. 检测和阻止访问本地地址（127.0.0.1, localhost 等）
-3. 检测和阻止访问私网地址（10.0.0.0, 172.16.0.0, 192.168.0.0, 等）
-4. 提供详细的审计日志
-
-作者: QAIU
-版本: 1.0.0
-"""
-
-import socket
-import sys
-from urllib.parse import urlparse
-
-
-# ===== IP 地址判断工具 =====
-
-# 常见内网/危险网段（可按需增删）
-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",        # 预留地址
-]
-
-# 危险端口列表（常见网络服务端口）
-DANGEROUS_PORTS = [
-    22,     # SSH
-    25,     # SMTP
-    53,     # DNS
-    3306,   # MySQL
-    5432,   # PostgreSQL
-    6379,   # Redis
-    8000, 8001, 8080, 8888,  # 常见开发服务器端口
-    27017,  # MongoDB
-]
-
-
-def _ip_in_nets(ip_str: str) -> bool:
-    """判断 IP 是否落在 PRIVATE_NETS 中的任一 CIDR"""
-    try:
-        from ipaddress import ip_address, ip_network
-        addr = ip_address(ip_str)
-        return any(addr in ip_network(cidr) for cidr in PRIVATE_NETS)
-    except (ValueError, ImportError):
-        # 如果解析失败（非IP地址）或模块不可用，返回False（不是私网IP）
-        return False
-
-
-def _hostname_resolves_to_private(hostname: str) -> bool:
-    """解析域名并判断解析结果是否落在私网"""
-    try:
-        _, _, ips = socket.gethostbyname_ex(hostname)
-        return any(_ip_in_nets(ip) for ip in ips)
-    except (OSError, socket.error):
-        # 解析失败（如网络问题、DNS不可用）：允许访问，不视为私网
-        # 仅当成功解析且落在私网时才拦截
-        return False
-
-
-def _is_dangerous_port(port):
-    """判断是否为危险端口"""
-    return port in DANGEROUS_PORTS
-
-
-# ===== 日志工具 =====
-
-class GuardLogger:
-    """网络请求卫士日志记录器"""
-    
-    # 用于去重的最近请求缓存（避免重复日志）
-    _recent_requests = set()
-    _max_cache_size = 100
-    
-    @staticmethod
-    def audit(level, message):
-        """输出审计日志"""
-        timestamp = _get_timestamp()
-        log_msg = f"[{timestamp}] [Guard-{level}] {message}"
-        print(log_msg)
-        # 可以在这里添加文件日志、数据库日志等
-        sys.stdout.flush()
-    
-    @staticmethod
-    def allow(method, url):
-        """记录允许的请求（带去重）"""
-        request_key = f"{method.upper()}:{url}"
-        if request_key not in GuardLogger._recent_requests:
-            GuardLogger._recent_requests.add(request_key)
-            # 限制缓存大小
-            if len(GuardLogger._recent_requests) > GuardLogger._max_cache_size:
-                GuardLogger._recent_requests.clear()
-            GuardLogger.audit("ALLOW", f"{method.upper():6} {url}")
-    
-    @staticmethod
-    def block(method, url, reason):
-        """记录被阻止的请求"""
-        GuardLogger.audit("BLOCK", f"{method.upper():6} {url} - {reason}")
-
-
-def _get_timestamp():
-    """获取当前时间戳"""
-    try:
-        from datetime import datetime
-        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
-    except ImportError:
-        return ""
-
-
-# ===== requests 库猴子补丁 =====
-
-def _patch_requests():
-    """为 requests 库应用猴子补丁"""
-    try:
-        import requests
-        from requests import models
-        
-        # 备份原始的 request 方法
-        _orig_request = requests.api.request
-        _orig_session_request = requests.Session.request
-        
-        # 备份高层快捷函数（在修改之前）
-        _orig_methods = {}
-        for method in ("get", "post", "put", "patch", "delete", "head", "options"):
-            _orig_methods[method] = getattr(requests, method, None)
-        
-        def _safe_request(method, url, **kwargs):
-            """安全的 request 包装函数"""
-            _validate_url(method, url)
-            GuardLogger.allow(method, url)
-            return _orig_request(method, url, **kwargs)
-        
-        def _safe_session_request(self, method, url, **kwargs):
-            """安全的 Session.request 包装函数"""
-            _validate_url(method, url)
-            GuardLogger.allow(method, url)
-            return _orig_session_request(self, method, url, **kwargs)
-        
-        # 应用猴子补丁
-        requests.api.request = _safe_request
-        requests.Session.request = _safe_session_request
-        
-        # 为了兼容高层快捷函数 get/post/...
-        for method_name, original_method in _orig_methods.items():
-            if original_method:
-                # 创建闭包保存当前方法名和原始方法
-                def make_safe_method(m, orig_func):
-                    def safe_method(url, **kwargs):
-                        _validate_url(m, url)
-                        GuardLogger.allow(m, url)
-                        return orig_func(url, **kwargs)
-                    return safe_method
-                setattr(requests, method_name, make_safe_method(method_name, original_method))
-        
-        GuardLogger.audit("INFO", "requests 库猴子补丁加载成功，已启用网络请求安全拦截")
-        return True
-        
-    except ImportError:
-        GuardLogger.audit("DEBUG", "requests 库未安装，跳过补丁")
-        return False
-    except Exception as e:
-        GuardLogger.audit("ERROR", f"requests 库补丁加载失败: {str(e)}")
-        return False
-
-
-# ===== urllib 库猴子补丁 =====
-
-def _patch_urllib():
-    """为 urllib 库应用猴子补丁"""
-    try:
-        import urllib.request
-        import urllib.error
-        
-        # 备份原始方法
-        _orig_urlopen = urllib.request.urlopen
-        
-        def _safe_urlopen(url, *args, **kwargs):
-            """安全的 urlopen 包装函数"""
-            if isinstance(url, str):
-                _validate_url("GET", url)
-                GuardLogger.allow("GET", url)
-            elif hasattr(url, 'get_full_url'):
-                # 处理 Request 对象
-                full_url = url.get_full_url()
-                _validate_url(url.get_method(), full_url)
-                GuardLogger.allow(url.get_method(), full_url)
-            
-            return _orig_urlopen(url, *args, **kwargs)
-        
-        # 应用猴子补丁
-        urllib.request.urlopen = _safe_urlopen
-        
-        GuardLogger.audit("INFO", "urllib 库猴子补丁加载成功")
-        return True
-        
-    except ImportError:
-        GuardLogger.audit("DEBUG", "urllib 库未安装或不可用，跳过补丁")
-        return False
-    except Exception as e:
-        GuardLogger.audit("ERROR", f"urllib 库补丁加载失败: {str(e)}")
-        return False
-
-
-# ===== 核心验证函数 =====
-
-def _validate_url(method: str, url: str):
-    """验证 URL 是否安全"""
-    if not isinstance(url, str):
-        raise ValueError(f"[Guard] 非法 URL 类型：{type(url)}")
-    
-    if not url or len(url) == 0:
-        raise ValueError("[Guard] URL 不能为空")
-    
-    # 解析 URL
-    try:
-        parsed = urlparse(url)
-    except Exception as e:
-        raise ValueError(f"[Guard] 无法解析 URL：{url} - {str(e)}")
-    
-    scheme = parsed.scheme.lower()
-    host = parsed.hostname
-    port = parsed.port
-    
-    # 检查协议（仅允许 http/https）
-    if scheme not in ("http", "https"):
-        GuardLogger.block(method, url, f"不允许的协议: {scheme}")
-        raise PermissionError(f"[Guard] 禁止访问不安全的协议：{scheme}://")
-    
-    if not host:
-        GuardLogger.block(method, url, "无法解析主机名")
-        raise ValueError(f"[Guard] 无法解析 URL 中的主机名：{url}")
-    
-    # 1. 快速检查本地地址
-    host_lower = host.lower()
-    if host_lower in ("localhost", "127.0.0.1", "::1", "[::1]"):
-        GuardLogger.block(method, url, "本地地址")
-        raise PermissionError(f"[Guard] 禁止访问本地地址：{url}")
-    
-    # 2. 检查危险端口
-    if port and _is_dangerous_port(port):
-        GuardLogger.block(method, url, f"危险端口 {port}")
-        raise PermissionError(f"[Guard] 禁止访问危险端口 {port}：{url}")
-    
-    # 3. 检查是否为 IP 地址或解析后落在私网网段
-    try:
-        # 判断 host 是否为纯 IP 地址（仅包含数字、点、冒号）
-        is_ip_format = all(c.isdigit() or c in '.:-[]' for c in host)
-        
-        if is_ip_format:
-            # 如果是 IP 格式，检查是否落在私网段
-            if _ip_in_nets(host):
-                GuardLogger.block(method, url, "私网IP地址")
-                raise PermissionError(f"[Guard] 禁止访问私网/危险地址：{url}")
-        else:
-            # 如果是域名，解析后检查是否指向私网
-            if _hostname_resolves_to_private(host):
-                GuardLogger.block(method, url, "域名解析到私网")
-                raise PermissionError(f"[Guard] 禁止访问私网/危险地址（域名解析）：{url}")
-    
-    except PermissionError:
-        raise  # 重新抛出 PermissionError
-    except Exception as e:
-        # 其他异常（如 DNS 解析异常）允许通过，仅记录警告
-        GuardLogger.audit("WARN", f"地址检查异常（已允许）: {url} - {str(e)}")
-
-
-# ===== 初始化和全局补丁应用 =====
-
-def apply_all_patches():
-    """应用所有网络库的补丁"""
-    print("[Guard] 正在初始化网络请求安全卫士...")
-    
-    patches_applied = []
-    
-    # 应用 requests 补丁
-    if _patch_requests():
-        patches_applied.append("requests")
-    
-    # 应用 urllib 补丁
-    if _patch_urllib():
-        patches_applied.append("urllib")
-    
-    if patches_applied:
-        msg = f"[Guard] 成功应用 {len(patches_applied)} 个网络库补丁: {', '.join(patches_applied)}"
-        GuardLogger.audit("INFO", msg)
-    else:
-        GuardLogger.audit("WARN", "[Guard] 没有可用的网络库可以补丁")
-
-
-# ===== 模块初始化 =====
-
-# 在模块加载时自动应用所有补丁
-apply_all_patches()
-
-# 暴露公共接口
-__all__ = [
-    'GuardLogger',
-    'apply_all_patches',
-    'PRIVATE_NETS',
-    'DANGEROUS_PORTS',
-]

parser/src/test/java/cn/qaiu/parser/GraalPyTest.java

@@ -1,57 +0,0 @@
-package cn.qaiu.parser;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Engine;
-import org.graalvm.polyglot.Value;
-
-/**
- * GraalPy 简单测试
- */
-public class GraalPyTest {
-    
-    public static void main(String[] args) {
-        System.out.println("===== GraalPy 测试开始 =====");
-        
-        try {
-            System.out.println("1. 检查可用语言...");
-            try (Engine engine = Engine.create()) {
-                System.out.println("   可用语言: " + engine.getLanguages().keySet());
-                if (!engine.getLanguages().containsKey("python")) {
-                    System.err.println("   ✗ Python 语言不可用！");
-                    System.exit(1);
-                }
-                System.out.println("   ✓ Python 语言可用");
-            }
-            
-            System.out.println("2. 尝试创建 Python Context...");
-            try (Context context = Context.newBuilder("python")
-                    .option("engine.WarnInterpreterOnly", "false")
-                    .build()) {
-                System.out.println("   ✓ Context 创建成功");
-                
-                System.out.println("3. 执行简单 Python 代码...");
-                Value result = context.eval("python", "1 + 2");
-                System.out.println("   ✓ 计算结果: 1 + 2 = " + result.asInt());
-                
-                System.out.println("4. 执行字符串操作...");
-                Value strResult = context.eval("python", "'Hello' + ' ' + 'GraalPy'");
-                System.out.println("   ✓ 字符串结果: " + strResult.asString());
-                
-                System.out.println("5. 执行多行代码...");
-                String code = """
-                    def greet(name):
-                        return f"Hello, {name}!"
-                    greet("World")
-                    """;
-                Value funcResult = context.eval("python", code);
-                System.out.println("   ✓ 函数结果: " + funcResult.asString());
-            }
-            
-            System.out.println("===== GraalPy 测试通过 =====");
-        } catch (Exception e) {
-            System.err.println("✗ GraalPy 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            System.exit(1);
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/PyCryptoUtilsTest.java

@@ -1,439 +0,0 @@
-package cn.qaiu.parser;
-
-import cn.qaiu.parser.custompy.PyCryptoUtils;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.nio.charset.StandardCharsets;
-
-import static org.junit.Assert.*;
-
-/**
- * PyCryptoUtils 测试类
- * 测试Python加密工具功能
- *
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2026/1/11
- */
-public class PyCryptoUtilsTest {
-
-    private PyCryptoUtils cryptoUtils;
-
-    @Before
-    public void setUp() {
-        cryptoUtils = new PyCryptoUtils();
-        System.out.println("--- 测试开始 ---");
-    }
-
-    // ===================== MD5 测试 =====================
-
-    @Test
-    public void testMd5() {
-        System.out.println("\n[测试] MD5哈希");
-        
-        // 测试已知值
-        String input = "hello";
-        String expected = "5d41402abc4b2a76b9719d911017c592";
-        
-        String result = cryptoUtils.md5(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("MD5: " + result);
-        System.out.println("期望: " + expected);
-        
-        assertEquals("MD5结果应该正确", expected, result);
-        assertEquals("MD5应该是32位", 32, result.length());
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testMd5_16() {
-        System.out.println("\n[测试] MD5-16位哈希");
-        
-        String input = "hello";
-        String fullMd5 = "5d41402abc4b2a76b9719d911017c592";
-        String expected = fullMd5.substring(8, 24); // "abc4b2a76b9719d9"
-        
-        String result = cryptoUtils.md5_16(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("MD5-16: " + result);
-        System.out.println("期望: " + expected);
-        
-        assertEquals("MD5-16结果应该正确", expected, result);
-        assertEquals("MD5-16应该是16位", 16, result.length());
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testMd5EmptyString() {
-        System.out.println("\n[测试] MD5空字符串");
-        
-        String input = "";
-        String expected = "d41d8cd98f00b204e9800998ecf8427e";
-        
-        String result = cryptoUtils.md5(input);
-        
-        System.out.println("输入: (空字符串)");
-        System.out.println("MD5: " + result);
-        
-        assertEquals("空字符串MD5应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    // ===================== SHA 测试 =====================
-
-    @Test
-    public void testSha1() {
-        System.out.println("\n[测试] SHA-1哈希");
-        
-        String input = "hello";
-        String expected = "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d";
-        
-        String result = cryptoUtils.sha1(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("SHA-1: " + result);
-        
-        assertEquals("SHA-1结果应该正确", expected, result);
-        assertEquals("SHA-1应该是40位", 40, result.length());
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testSha256() {
-        System.out.println("\n[测试] SHA-256哈希");
-        
-        String input = "hello";
-        String expected = "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824";
-        
-        String result = cryptoUtils.sha256(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("SHA-256: " + result);
-        
-        assertEquals("SHA-256结果应该正确", expected, result);
-        assertEquals("SHA-256应该是64位", 64, result.length());
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testSha512() {
-        System.out.println("\n[测试] SHA-512哈希");
-        
-        String input = "hello";
-        
-        String result = cryptoUtils.sha512(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("SHA-512: " + result);
-        
-        assertNotNull("SHA-512结果不能为null", result);
-        assertEquals("SHA-512应该是128位", 128, result.length());
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    // ===================== Base64 测试 =====================
-
-    @Test
-    public void testBase64Encode() {
-        System.out.println("\n[测试] Base64编码");
-        
-        String input = "hello world";
-        String expected = "aGVsbG8gd29ybGQ=";
-        
-        String result = cryptoUtils.base64_encode(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("Base64: " + result);
-        
-        assertEquals("Base64编码应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testBase64Decode() {
-        System.out.println("\n[测试] Base64解码");
-        
-        String input = "aGVsbG8gd29ybGQ=";
-        String expected = "hello world";
-        
-        String result = cryptoUtils.base64_decode(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("解码: " + result);
-        
-        assertEquals("Base64解码应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testBase64EncodeBytes() {
-        System.out.println("\n[测试] Base64字节编码");
-        
-        byte[] input = "hello".getBytes(StandardCharsets.UTF_8);
-        String expected = "aGVsbG8=";
-        
-        String result = cryptoUtils.base64_encode_bytes(input);
-        
-        System.out.println("输入字节数: " + input.length);
-        System.out.println("Base64: " + result);
-        
-        assertEquals("Base64字节编码应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testBase64UrlEncode() {
-        System.out.println("\n[测试] Base64 URL安全编码");
-        
-        // 包含特殊字符的测试数据
-        String input = "hello+world/test";
-        
-        String result = cryptoUtils.base64_url_encode(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("Base64 URL: " + result);
-        
-        assertNotNull("结果不能为null", result);
-        assertFalse("URL安全编码不应该包含+", result.contains("+"));
-        assertFalse("URL安全编码不应该包含/", result.contains("/"));
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testBase64UrlDecode() {
-        System.out.println("\n[测试] Base64 URL安全解码");
-        
-        String input = "aGVsbG8td29ybGQ";
-        String expected = "hello-world";
-        
-        String result = cryptoUtils.base64_url_decode(input);
-        
-        System.out.println("输入: " + input);
-        System.out.println("解码: " + result);
-        
-        assertEquals("Base64 URL解码应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testBase64RoundTrip() {
-        System.out.println("\n[测试] Base64编解码往返");
-        
-        String[] testCases = {
-            "hello",
-            "hello world",
-            "中文测试",
-            "特殊字符!@#$%^&*()",
-            ""
-        };
-        
-        for (String original : testCases) {
-            String encoded = cryptoUtils.base64_encode(original);
-            String decoded = cryptoUtils.base64_decode(encoded);
-            
-            assertEquals("编解码往返应该得到原值: " + original, original, decoded);
-        }
-        
-        System.out.println("✓ 测试通过（" + testCases.length + " 个测试用例）");
-    }
-
-    // ===================== AES 测试 =====================
-
-    @Test
-    public void testAesEcbEncryptDecrypt() {
-        System.out.println("\n[测试] AES ECB模式加解密");
-        
-        String plaintext = "hello world 123";
-        String key = "1234567890123456"; // 16字节密钥
-        
-        // 加密
-        String encrypted = cryptoUtils.aes_encrypt_ecb(plaintext, key);
-        System.out.println("原文: " + plaintext);
-        System.out.println("密钥: " + key);
-        System.out.println("密文: " + encrypted);
-        
-        assertNotNull("加密结果不能为null", encrypted);
-        assertNotEquals("加密后应该不同于原文", plaintext, encrypted);
-        
-        // 解密
-        String decrypted = cryptoUtils.aes_decrypt_ecb(encrypted, key);
-        System.out.println("解密: " + decrypted);
-        
-        assertEquals("解密后应该恢复原文", plaintext, decrypted);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testAesCbcEncryptDecrypt() {
-        System.out.println("\n[测试] AES CBC模式加解密");
-        
-        String plaintext = "hello world 123";
-        String key = "1234567890123456"; // 16字节密钥
-        String iv = "abcdefghijklmnop";  // 16字节IV
-        
-        // 加密
-        String encrypted = cryptoUtils.aes_encrypt_cbc(plaintext, key, iv);
-        System.out.println("原文: " + plaintext);
-        System.out.println("密钥: " + key);
-        System.out.println("IV: " + iv);
-        System.out.println("密文: " + encrypted);
-        
-        assertNotNull("加密结果不能为null", encrypted);
-        assertNotEquals("加密后应该不同于原文", plaintext, encrypted);
-        
-        // 解密
-        String decrypted = cryptoUtils.aes_decrypt_cbc(encrypted, key, iv);
-        System.out.println("解密: " + decrypted);
-        
-        assertEquals("解密后应该恢复原文", plaintext, decrypted);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testAesWithChineseContent() {
-        System.out.println("\n[测试] AES加密中文内容");
-        
-        String plaintext = "这是一段中文内容123";
-        String key = "1234567890123456";
-        String iv = "abcdefghijklmnop";
-        
-        // ECB模式
-        String encryptedEcb = cryptoUtils.aes_encrypt_ecb(plaintext, key);
-        String decryptedEcb = cryptoUtils.aes_decrypt_ecb(encryptedEcb, key);
-        assertEquals("ECB解密中文应该正确", plaintext, decryptedEcb);
-        
-        // CBC模式
-        String encryptedCbc = cryptoUtils.aes_encrypt_cbc(plaintext, key, iv);
-        String decryptedCbc = cryptoUtils.aes_decrypt_cbc(encryptedCbc, key, iv);
-        assertEquals("CBC解密中文应该正确", plaintext, decryptedCbc);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testAesEcbCbcDifference() {
-        System.out.println("\n[测试] AES ECB和CBC模式差异");
-        
-        String plaintext = "hello world 1234";
-        String key = "1234567890123456";
-        String iv = "abcdefghijklmnop";
-        
-        String ecbEncrypted = cryptoUtils.aes_encrypt_ecb(plaintext, key);
-        String cbcEncrypted = cryptoUtils.aes_encrypt_cbc(plaintext, key, iv);
-        
-        System.out.println("ECB密文: " + ecbEncrypted);
-        System.out.println("CBC密文: " + cbcEncrypted);
-        
-        // ECB和CBC模式的加密结果应该不同
-        assertNotEquals("ECB和CBC加密结果应该不同", ecbEncrypted, cbcEncrypted);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    // ===================== 工具方法测试 =====================
-
-    @Test
-    public void testBytesToHex() {
-        System.out.println("\n[测试] 字节转十六进制");
-        
-        byte[] input = {0x00, 0x0F, (byte) 0xFF, 0x10, (byte) 0xAB};
-        String expected = "000fff10ab";
-        
-        String result = cryptoUtils.bytes_to_hex(input);
-        
-        System.out.println("输入字节: " + input.length + " 字节");
-        System.out.println("十六进制: " + result);
-        
-        assertEquals("字节转十六进制应该正确", expected, result);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testConsistencyWithJsCryptoUtils() {
-        System.out.println("\n[测试] 与JavaScript加密工具一致性");
-        
-        // 这些值应该与JsCryptoUtils产生相同的结果
-        String testString = "consistency_test";
-        
-        String md5 = cryptoUtils.md5(testString);
-        String sha1 = cryptoUtils.sha1(testString);
-        String sha256 = cryptoUtils.sha256(testString);
-        String base64 = cryptoUtils.base64_encode(testString);
-        
-        System.out.println("测试字符串: " + testString);
-        System.out.println("MD5: " + md5);
-        System.out.println("SHA1: " + sha1);
-        System.out.println("SHA256: " + sha256);
-        System.out.println("Base64: " + base64);
-        
-        // 验证结果非空且格式正确
-        assertNotNull("MD5不能为null", md5);
-        assertEquals("MD5长度应该是32", 32, md5.length());
-        
-        assertNotNull("SHA1不能为null", sha1);
-        assertEquals("SHA1长度应该是40", 40, sha1.length());
-        
-        assertNotNull("SHA256不能为null", sha256);
-        assertEquals("SHA256长度应该是64", 64, sha256.length());
-        
-        assertNotNull("Base64不能为null", base64);
-        
-        System.out.println("✓ 测试通过");
-    }
-
-    @Test
-    public void testNullInput() {
-        System.out.println("\n[测试] 空输入处理");
-        
-        try {
-            // MD5应该能处理null（返回null或抛出异常）
-            String result = cryptoUtils.md5(null);
-            // 如果没有抛出异常，结果应该是null
-            System.out.println("MD5(null) = " + result);
-        } catch (Exception e) {
-            System.out.println("MD5(null) 抛出异常: " + e.getClass().getSimpleName());
-        }
-        
-        System.out.println("✓ 空输入处理测试完成");
-    }
-
-    @Test
-    public void testSpecialCharacters() {
-        System.out.println("\n[测试] 特殊字符处理");
-        
-        String[] testCases = {
-            "~!@#$%^&*()_+",
-            "日本語テスト",
-            "🎉🎊🎁",
-            "\n\t\r",
-            "   "
-        };
-        
-        for (String input : testCases) {
-            String md5 = cryptoUtils.md5(input);
-            String base64 = cryptoUtils.base64_encode(input);
-            String decoded = cryptoUtils.base64_decode(base64);
-            
-            assertNotNull("MD5不能为null", md5);
-            assertEquals("Base64往返应该正确", input, decoded);
-        }
-        
-        System.out.println("✓ 测试通过（" + testCases.length + " 个测试用例）");
-    }
-}

parser/src/test/java/cn/qaiu/parser/PyHttpClientTest.java

@@ -1,515 +0,0 @@
-package cn.qaiu.parser;
-
-import cn.qaiu.WebClientVertxInit;
-import cn.qaiu.parser.custompy.PyHttpClient;
-import io.vertx.core.Vertx;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.junit.Assert.*;
-
-/**
- * PyHttpClient 测试类
- * 测试Python HTTP客户端功能是否正常
- *
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2026/1/11
- */
-public class PyHttpClientTest {
-
-    private static Vertx vertx;
-    private PyHttpClient httpClient;
-
-    @BeforeClass
-    public static void init() {
-        // 初始化Vertx
-        vertx = Vertx.vertx();
-        WebClientVertxInit.init(vertx);
-        System.out.println("=== PyHttpClient测试初始化完成 ===\n");
-    }
-
-    @Before
-    public void setUp() {
-        // 创建PyHttpClient实例
-        httpClient = new PyHttpClient();
-        System.out.println("--- 测试开始 ---");
-    }
-
-    @After
-    public void tearDown() {
-        System.out.println("--- 测试结束 ---\n");
-    }
-
-    @Test
-    public void testSimpleGetRequest() {
-        System.out.println("\n[测试1] 简单GET请求 - httpbin.org/get");
-        
-        try {
-            String url = "https://httpbin.org/get";
-            System.out.println("请求URL: " + url);
-            
-            long startTime = System.currentTimeMillis();
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            long endTime = System.currentTimeMillis();
-            
-            System.out.println("请求完成，耗时: " + (endTime - startTime) + "ms");
-            System.out.println("状态码: " + response.status_code());
-            
-            String body = response.text();
-            System.out.println("响应体长度: " + (body != null ? body.length() : 0) + " 字符");
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("请求应该成功", response.ok());
-            assertNotNull("响应体不能为null", body);
-            assertTrue("响应体应该包含url字段", body.contains("\"url\""));
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("GET请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testGetWithRedirect() {
-        System.out.println("\n[测试2] GET请求（跟随重定向）");
-        
-        try {
-            String url = "https://httpbin.org/redirect/1";
-            System.out.println("请求URL: " + url);
-            
-            PyHttpClient.PyHttpResponse response = httpClient.get_with_redirect(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200（重定向后）", 200, response.status_code());
-            assertTrue("请求应该成功", response.ok());
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("GET重定向请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testGetNoRedirect() {
-        System.out.println("\n[测试3] GET请求（不跟随重定向）");
-        
-        try {
-            String url = "https://httpbin.org/redirect/1";
-            System.out.println("请求URL: " + url);
-            
-            PyHttpClient.PyHttpResponse response = httpClient.get_no_redirect(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            String location = response.header("Location");
-            System.out.println("Location头: " + location);
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertTrue("状态码应该是3xx重定向", 
-                    response.status_code() >= 300 && response.status_code() < 400);
-            assertFalse("ok()应该返回false", response.ok());
-            assertNotNull("应该有Location头", location);
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("GET不重定向请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testPostFormData() {
-        System.out.println("\n[测试4] POST表单数据");
-        
-        try {
-            String url = "https://httpbin.org/post";
-            Map<String, String> formData = new HashMap<>();
-            formData.put("username", "testuser");
-            formData.put("password", "testpass");
-            
-            System.out.println("请求URL: " + url);
-            System.out.println("表单数据: " + formData);
-            
-            PyHttpClient.PyHttpResponse response = httpClient.post(url, formData);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            String body = response.text();
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("响应体应该包含username", body.contains("testuser"));
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("POST表单数据失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testPostJson() {
-        System.out.println("\n[测试5] POST JSON数据");
-        
-        try {
-            String url = "https://httpbin.org/post";
-            Map<String, Object> jsonData = new HashMap<>();
-            jsonData.put("name", "测试用户");
-            jsonData.put("age", 25);
-            jsonData.put("active", true);
-            
-            System.out.println("请求URL: " + url);
-            System.out.println("JSON数据: " + jsonData);
-            
-            PyHttpClient.PyHttpResponse response = httpClient.post_json(url, jsonData);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            String body = response.text();
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("响应体应该包含json数据", body.contains("测试用户") || body.contains("name"));
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("POST JSON数据失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testCustomHeaders() {
-        System.out.println("\n[测试6] 自定义请求头");
-        
-        try {
-            String url = "https://httpbin.org/headers";
-            
-            // 设置自定义请求头
-            httpClient.put_header("X-Custom-Header", "CustomValue")
-                      .put_header("X-Another-Header", "AnotherValue");
-            
-            System.out.println("请求URL: " + url);
-            
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            String body = response.text();
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("响应体应该包含自定义头", body.contains("X-Custom-Header"));
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("自定义请求头测试失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testBatchHeaders() {
-        System.out.println("\n[测试7] 批量设置请求头");
-        
-        try {
-            String url = "https://httpbin.org/headers";
-            
-            Map<String, String> headers = new HashMap<>();
-            headers.put("X-Header-1", "Value1");
-            headers.put("X-Header-2", "Value2");
-            headers.put("X-Header-3", "Value3");
-            
-            // 先清除之前的头
-            httpClient.clear_headers();
-            httpClient.put_headers(headers);
-            
-            System.out.println("请求URL: " + url);
-            System.out.println("批量设置 " + headers.size() + " 个请求头");
-            
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("批量设置请求头测试失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testResponseJson() {
-        System.out.println("\n[测试8] 解析JSON响应");
-        
-        try {
-            String url = "https://httpbin.org/json";
-            
-            System.out.println("请求URL: " + url);
-            
-            // 清除之前设置的头
-            httpClient.clear_headers();
-            
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            Object jsonObj = response.json();
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertNotNull("JSON对象不能为null", jsonObj);
-            
-            System.out.println("JSON类型: " + jsonObj.getClass().getSimpleName());
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("解析JSON响应失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testResponseHeader() {
-        System.out.println("\n[测试9] 获取响应头");
-        
-        try {
-            String url = "https://httpbin.org/response-headers?X-Test-Header=TestValue";
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            String contentType = response.header("Content-Type");
-            System.out.println("Content-Type: " + contentType);
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertNotNull("应该有Content-Type头", contentType);
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("获取响应头失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testContentLength() {
-        System.out.println("\n[测试10] 获取内容长度");
-        
-        try {
-            String url = "https://httpbin.org/bytes/1024";
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            long contentLength = response.content_length();
-            System.out.println("Content-Length: " + contentLength);
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("内容长度应该大于0", contentLength > 0);
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("获取内容长度失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testPutRequest() {
-        System.out.println("\n[测试11] PUT请求");
-        
-        try {
-            String url = "https://httpbin.org/put";
-            Map<String, String> data = new HashMap<>();
-            data.put("key", "value");
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.put(url, data);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("PUT请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testDeleteRequest() {
-        System.out.println("\n[测试12] DELETE请求");
-        
-        try {
-            String url = "https://httpbin.org/delete";
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.delete(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("DELETE请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testPatchRequest() {
-        System.out.println("\n[测试13] PATCH请求");
-        
-        try {
-            String url = "https://httpbin.org/patch";
-            Map<String, String> data = new HashMap<>();
-            data.put("field", "updated");
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.patch(url, data);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("PATCH请求失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testMethodChaining() {
-        System.out.println("\n[测试14] 方法链式调用");
-        
-        try {
-            String url = "https://httpbin.org/headers";
-            
-            System.out.println("请求URL: " + url);
-            
-            // 测试链式调用
-            PyHttpClient.PyHttpResponse response = new PyHttpClient()
-                    .put_header("X-Chain-1", "Value1")
-                    .put_header("X-Chain-2", "Value2")
-                    .set_timeout(30)
-                    .get(url);
-            
-            System.out.println("状态码: " + response.status_code());
-            
-            String body = response.text();
-            
-            // 验证结果
-            assertNotNull("响应不能为null", response);
-            assertEquals("状态码应该是200", 200, response.status_code());
-            assertTrue("响应体应该包含链式设置的头", body.contains("X-Chain"));
-            
-            System.out.println("✓ 测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("方法链式调用测试失败: " + e.getMessage());
-        }
-    }
-
-    @Test
-    public void testBodyAndTextEquivalent() {
-        System.out.println("\n[测试15] body()和text()方法等价性");
-        
-        try {
-            String url = "https://httpbin.org/get";
-            
-            System.out.println("请求URL: " + url);
-            
-            httpClient.clear_headers();
-            PyHttpClient.PyHttpResponse response = httpClient.get(url);
-            
-            String body = response.body();
-            String text = response.text();
-            
-            // 验证结果
-            assertEquals("body()和text()应该返回相同的结果", body, text);
-            
-            System.out.println("✓ 测试通过");
-            System.out.println("  body() == text(): " + body.equals(text));
-            
-        } catch (Exception e) {
-            System.err.println("✗ 测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("body()和text()等价性测试失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/PyParserTest.java

@@ -1,558 +0,0 @@
-package cn.qaiu.parser;
-
-import cn.qaiu.entity.FileInfo;
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.custom.CustomParserRegistry;
-import cn.qaiu.parser.custompy.*;
-import cn.qaiu.WebClientVertxInit;
-import io.vertx.core.Vertx;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.*;
-
-/**
- * Python解析器测试
- * 测试GraalPy Python解析器的核心功能
- *
- * @author <a href="https://qaiu.top">QAIU</a>
- * Create at 2026/1/11
- */
-public class PyParserTest {
-    
-    private static Vertx vertx;
-    
-    @BeforeClass
-    public static void init() {
-        // 初始化Vertx
-        vertx = Vertx.vertx();
-        WebClientVertxInit.init(vertx);
-        System.out.println("=== Python解析器测试初始化完成 ===\n");
-    }
-    
-    @Before
-    public void setUp() {
-        // 清理注册表
-        CustomParserRegistry.clear();
-    }
-    
-    @Test
-    public void testPyContextPoolInitialization() {
-        System.out.println("\n[测试] Context池初始化");
-        
-        try {
-            PyContextPool pool = PyContextPool.getInstance();
-            
-            assertNotNull("Context池实例不能为null", pool);
-            assertFalse("Context池不应该是关闭状态", pool.isClosed());
-            assertTrue("应该有可用的Context", pool.getCreatedCount() > 0);
-            
-            System.out.println("✓ Context池初始化测试通过");
-            System.out.println("  " + pool.getStatus());
-            
-        } catch (Exception e) {
-            System.err.println("✗ Context池初始化测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Context池初始化失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPyContextPoolAcquireRelease() throws Exception {
-        System.out.println("\n[测试] Context池获取和释放");
-        
-        try {
-            PyContextPool pool = PyContextPool.getInstance();
-            
-            // 获取Context
-            PyContextPool.PooledContext pc = pool.acquire();
-            assertNotNull("获取的Context不能为null", pc);
-            assertNotNull("底层Context不能为null", pc.getContext());
-            assertFalse("Context不应该过期", pc.isExpired());
-            
-            int availableBefore = pool.getAvailableCount();
-            
-            // 释放Context
-            pc.close();
-            
-            // 验证归还后可用数量增加
-            int availableAfter = pool.getAvailableCount();
-            assertTrue("归还后可用数量应该增加", availableAfter >= availableBefore);
-            
-            System.out.println("✓ Context池获取和释放测试通过");
-            
-        } catch (Exception e) {
-            System.err.println("✗ Context池获取和释放测试失败: " + e.getMessage());
-            e.printStackTrace();
-            throw e;
-        }
-    }
-    
-    @Test
-    public void testSimplePythonExecution() {
-        System.out.println("\n[测试] 简单Python代码执行");
-        
-        String pyCode = """
-            # 简单测试
-            def parse(share_link_info, http, logger):
-                logger.info("测试日志")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            assertNotNull("执行结果不能为null", result);
-            assertTrue("应该返回下载链接", result.contains("example.com"));
-            
-            // 检查日志
-            List<PyPlaygroundLogger.LogEntry> logs = executor.getLogs();
-            assertFalse("应该有日志输出", logs.isEmpty());
-            
-            System.out.println("✓ 简单Python代码执行测试通过");
-            System.out.println("  返回结果: " + result);
-            System.out.println("  日志数量: " + logs.size());
-            
-        } catch (Exception e) {
-            System.err.println("✗ 简单Python代码执行测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python执行失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonHttpRequest() {
-        System.out.println("\n[测试] Python HTTP请求功能");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                logger.info("开始HTTP请求测试")
-                
-                # 发送GET请求
-                response = http.get("https://httpbin.org/get")
-                
-                if response.ok():
-                    logger.info(f"请求成功，状态码: {response.status_code()}")
-                    return "https://example.com/success"
-                else:
-                    logger.error(f"请求失败，状态码: {response.status_code()}")
-                    return "https://example.com/failed"
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(60, TimeUnit.SECONDS);
-            
-            assertNotNull("执行结果不能为null", result);
-            assertTrue("应该返回成功链接", result.contains("success"));
-            
-            System.out.println("✓ Python HTTP请求功能测试通过");
-            System.out.println("  返回结果: " + result);
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python HTTP请求功能测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python HTTP请求失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonCryptoUtils() {
-        System.out.println("\n[测试] Python加密工具功能");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                # 测试MD5
-                md5_result = crypto.md5("hello")
-                logger.info(f"MD5: {md5_result}")
-                
-                # 测试SHA256
-                sha256_result = crypto.sha256("hello")
-                logger.info(f"SHA256: {sha256_result}")
-                
-                # 测试Base64编码解码
-                b64_encoded = crypto.base64_encode("hello world")
-                b64_decoded = crypto.base64_decode(b64_encoded)
-                logger.info(f"Base64: {b64_encoded} -> {b64_decoded}")
-                
-                # 验证MD5正确性
-                if md5_result == "5d41402abc4b2a76b9719d911017c592":
-                    return "https://example.com/crypto_success"
-                else:
-                    return "https://example.com/crypto_failed"
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            assertNotNull("执行结果不能为null", result);
-            assertTrue("加密工具应该正常工作", result.contains("crypto_success"));
-            
-            System.out.println("✓ Python加密工具功能测试通过");
-            System.out.println("  返回结果: " + result);
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python加密工具功能测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python加密工具测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonShareLinkInfo() {
-        System.out.println("\n[测试] Python ShareLinkInfo访问");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                # 获取分享链接信息
-                url = share_link_info.get_share_url()
-                key = share_link_info.get_share_key()
-                pwd = share_link_info.get_share_password()
-                
-                logger.info(f"URL: {url}")
-                logger.info(f"Key: {key}")
-                logger.info(f"Password: {pwd}")
-                
-                # 测试其他参数
-                custom_param = share_link_info.get_other_param("customKey")
-                logger.info(f"CustomKey: {custom_param}")
-                
-                if url and key:
-                    return f"https://example.com/download/{key}"
-                else:
-                    return "https://example.com/failed"
-            """;
-        
-        try {
-            Map<String, Object> otherParams = new HashMap<>();
-            otherParams.put("customKey", "customValue");
-            
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/mykey123")
-                    .shareKey("mykey123")
-                    .sharePassword("mypassword")
-                    .otherParam(otherParams)
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            assertNotNull("执行结果不能为null", result);
-            assertTrue("应该包含正确的key", result.contains("mykey123"));
-            
-            System.out.println("✓ Python ShareLinkInfo访问测试通过");
-            System.out.println("  返回结果: " + result);
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python ShareLinkInfo访问测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python ShareLinkInfo访问失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonFileListParsing() {
-        System.out.println("\n[测试] Python文件列表解析");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                return "https://example.com/download/single.zip"
-            
-            def parse_file_list(share_link_info, http, logger):
-                logger.info("开始解析文件列表")
-                
-                # 返回文件列表
-                file_list = [
-                    {
-                        "file_name": "测试文件1.txt",
-                        "file_id": "file001",
-                        "file_type": "txt",
-                        "size": 1024,
-                        "pan_type": "custom"
-                    },
-                    {
-                        "file_name": "测试文件2.zip",
-                        "file_id": "file002",
-                        "file_type": "zip",
-                        "size": 2048,
-                        "pan_type": "custom"
-                    }
-                ]
-                
-                logger.info(f"解析到 {len(file_list)} 个文件")
-                return file_list
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            List<FileInfo> fileList = executor.executeParseFileListAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            assertNotNull("文件列表不能为null", fileList);
-            assertEquals("应该有2个文件", 2, fileList.size());
-            
-            FileInfo firstFile = fileList.get(0);
-            assertEquals("第一个文件名应该正确", "测试文件1.txt", firstFile.getFileName());
-            assertEquals("第一个文件ID应该正确", "file001", firstFile.getFileId());
-            
-            System.out.println("✓ Python文件列表解析测试通过");
-            System.out.println("  文件数量: " + fileList.size());
-            for (FileInfo file : fileList) {
-                System.out.println("  - " + file.getFileName() + " (" + file.getSize() + " bytes)");
-            }
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python文件列表解析测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python文件列表解析失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonParseById() {
-        System.out.println("\n[测试] Python按ID解析");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                return "https://example.com/download/single.zip"
-            
-            def parse_by_id(share_link_info, http, logger):
-                # 获取文件ID参数
-                param_json = share_link_info.get_other_param("paramJson")
-                
-                if param_json and hasattr(param_json, 'fileId'):
-                    file_id = param_json.fileId
-                else:
-                    file_id = "default_id"
-                
-                logger.info(f"按ID解析: {file_id}")
-                return f"https://example.com/download/{file_id}"
-            """;
-        
-        try {
-            Map<String, Object> otherParams = new HashMap<>();
-            io.vertx.core.json.JsonObject paramJson = new io.vertx.core.json.JsonObject();
-            paramJson.put("fileId", "myfile123");
-            otherParams.put("paramJson", paramJson);
-            
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(otherParams)
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseByIdAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            assertNotNull("执行结果不能为null", result);
-            assertTrue("应该包含文件ID", result.contains("download"));
-            
-            System.out.println("✓ Python按ID解析测试通过");
-            System.out.println("  返回结果: " + result);
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python按ID解析测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python按ID解析失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonErrorHandling() {
-        System.out.println("\n[测试] Python错误处理");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                # 故意抛出异常
-                raise ValueError("测试错误处理")
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            try {
-                executor.executeParseAsync()
-                        .toCompletionStage()
-                        .toCompletableFuture()
-                        .get(30, TimeUnit.SECONDS);
-                
-                fail("应该抛出异常");
-                
-            } catch (Exception e) {
-                // 预期的异常
-                assertTrue("异常信息应该包含错误内容", 
-                        e.getMessage().contains("ValueError") || 
-                        e.getCause().getMessage().contains("ValueError"));
-                
-                System.out.println("✓ Python错误处理测试通过");
-                System.out.println("  捕获到预期的异常: " + e.getMessage());
-            }
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python错误处理测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python错误处理测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonSandboxSecurity() {
-        System.out.println("\n[测试] Python沙箱安全性");
-        
-        // 测试禁止文件系统访问
-        String pyCode = """
-            import os
-            
-            def parse(share_link_info, http, logger):
-                try:
-                    # 尝试读取文件（应该被拒绝）
-                    with open("/etc/passwd", "r") as f:
-                        content = f.read()
-                    return "https://example.com/security_breach"
-                except Exception as e:
-                    logger.info(f"文件访问被正确拒绝: {type(e).__name__}")
-                    return "https://example.com/security_ok"
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            String result = executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            // 如果返回security_ok或抛出异常都表示安全机制工作正常
-            assertTrue("沙箱应该阻止文件访问", 
-                    result.contains("security_ok") || !result.contains("security_breach"));
-            
-            System.out.println("✓ Python沙箱安全性测试通过");
-            System.out.println("  返回结果: " + result);
-            
-        } catch (Exception e) {
-            // 如果直接抛出异常也表示安全机制工作正常
-            System.out.println("✓ Python沙箱安全性测试通过（抛出异常）");
-            System.out.println("  异常信息: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonLoggerLevels() {
-        System.out.println("\n[测试] Python日志级别");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                logger.debug("这是DEBUG日志")
-                logger.info("这是INFO日志")
-                logger.warn("这是WARN日志")
-                logger.error("这是ERROR日志")
-                return "https://example.com/log_test"
-            """;
-        
-        try {
-            ShareLinkInfo linkInfo = ShareLinkInfo.newBuilder()
-                    .shareUrl("https://example.com/s/test123")
-                    .shareKey("test123")
-                    .otherParam(new HashMap<>())
-                    .build();
-            
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(linkInfo, pyCode);
-            
-            executor.executeParseAsync()
-                    .toCompletionStage()
-                    .toCompletableFuture()
-                    .get(30, TimeUnit.SECONDS);
-            
-            List<PyPlaygroundLogger.LogEntry> logs = executor.getLogs();
-            
-            // 检查各个级别的日志
-            boolean hasDebug = logs.stream().anyMatch(l -> "DEBUG".equals(l.getLevel()));
-            boolean hasInfo = logs.stream().anyMatch(l -> "INFO".equals(l.getLevel()));
-            boolean hasWarn = logs.stream().anyMatch(l -> "WARN".equals(l.getLevel()));
-            boolean hasError = logs.stream().anyMatch(l -> "ERROR".equals(l.getLevel()));
-            
-            System.out.println("✓ Python日志级别测试通过");
-            System.out.println("  日志数量: " + logs.size());
-            System.out.println("  DEBUG: " + hasDebug);
-            System.out.println("  INFO: " + hasInfo);
-            System.out.println("  WARN: " + hasWarn);
-            System.out.println("  ERROR: " + hasError);
-            
-            for (PyPlaygroundLogger.LogEntry log : logs) {
-                System.out.println("  [" + log.getLevel() + "] " + log.getMessage());
-            }
-            
-        } catch (Exception e) {
-            System.err.println("✗ Python日志级别测试失败: " + e.getMessage());
-            e.printStackTrace();
-            fail("Python日志级别测试失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/GraalPyContextTest.java

@@ -1,88 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.python.embedding.utils.GraalPyResources;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.junit.Assert.*;
-
-/**
- * GraalPy Context 创建测试
- */
-public class GraalPyContextTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(GraalPyContextTest.class);
-    
-    @Test
-    public void testBasicContextCreation() {
-        log.info("==== 测试基础 Context 创建 ====");
-        
-        try {
-            // 检查 VFS 资源
-            var vfsResource = getClass().getClassLoader().getResource("org.graalvm.python.vfs/venv");
-            var homeResource = getClass().getClassLoader().getResource("org.graalvm.python.vfs/home");
-            log.info("VFS资源检查:");
-            log.info("  venv: {}", vfsResource != null ? "存在 -> " + vfsResource : "不存在");
-            log.info("  home: {}", homeResource != null ? "存在 -> " + homeResource : "不存在");
-            
-            // 使用 GraalPyResources 创建 Context
-            log.info("创建 GraalPyResources Context...");
-            
-            try (Context ctx = GraalPyResources.contextBuilder().build()) {
-                log.info("✓ Context 创建成功");
-                
-                // 简单的 Python 测试
-                ctx.eval("python", "print('Hello from GraalPy!')");
-                log.info("✓ Python 执行成功");
-                
-                // 测试 sys.path
-                ctx.eval("python", """
-                    import sys
-                    print("sys.path:")
-                    for p in sys.path[:5]:
-                        print(f"  {p}")
-                    """);
-                
-                // 尝试导入 requests
-                try {
-                    ctx.eval("python", "import requests");
-                    log.info("✓ requests 导入成功");
-                    
-                    var version = ctx.eval("python", "requests.__version__");
-                    log.info("✓ requests 版本: {}", version.asString());
-                } catch (Exception e) {
-                    log.warn("requests 导入失败: {}", e.getMessage());
-                }
-            }
-            
-        } catch (Exception e) {
-            log.error("测试失败", e);
-            fail("测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPoolContextCreation() {
-        log.info("==== 测试 PyContextPool Context 创建 ====");
-        
-        try {
-            PyContextPool pool = PyContextPool.getInstance();
-            log.info("PyContextPool 实例获取成功");
-            
-            try (Context ctx = pool.createFreshContext()) {
-                log.info("✓ FreshContext 创建成功");
-                
-                // 简单 Python 测试
-                ctx.eval("python", "print('Hello from Pool Context!')");
-                log.info("✓ Python 执行成功");
-                
-            }
-        } catch (Exception e) {
-            log.error("测试失败", e);
-            e.printStackTrace();
-            fail("测试失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/GraalPyDiagnosticTest.java

@@ -1,143 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.graalvm.polyglot.io.IOAccess;
-import org.graalvm.polyglot.HostAccess;
-import org.graalvm.python.embedding.utils.GraalPyResources;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.net.URL;
-
-/**
- * 简单的 GraalPy 诊断测试
- */
-public class GraalPyDiagnosticTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(GraalPyDiagnosticTest.class);
-    
-    @Test
-    public void diagnoseClaspath() {
-        log.info("==== 诊断 Classpath 和 VFS 资源 ====");
-        
-        // 1. 检查 classpath
-        String classpath = System.getProperty("java.class.path");
-        log.info("Java classpath: {}", classpath);
-        
-        // 2. 检查当前工作目录
-        String workingDir = System.getProperty("user.dir");
-        log.info("Working directory: {}", workingDir);
-        
-        // 3. 检查 VFS 资源
-        ClassLoader cl = getClass().getClassLoader();
-        
-        URL vfsVenv = cl.getResource("org.graalvm.python.vfs/venv");
-        URL vfsHome = cl.getResource("org.graalvm.python.vfs/home");
-        URL vfsRoot = cl.getResource("org.graalvm.python.vfs");
-        
-        log.info("VFS venv resource: {}", vfsVenv);
-        log.info("VFS home resource: {}", vfsHome);
-        log.info("VFS root resource: {}", vfsRoot);
-        
-        if (vfsVenv != null) {
-            log.info("✓ VFS venv 资源存在");
-            
-            // 检查 site-packages
-            URL sitePackages = cl.getResource("org.graalvm.python.vfs/venv/lib/python3.11/site-packages");
-            log.info("site-packages resource: {}", sitePackages);
-            
-            URL requestsPkg = cl.getResource("org.graalvm.python.vfs/venv/lib/python3.11/site-packages/requests");
-            log.info("requests package resource: {}", requestsPkg);
-            
-            if (requestsPkg != null) {
-                log.info("✓ requests 包资源存在");
-            } else {
-                log.error("✗ requests 包资源不存在");
-            }
-        } else {
-            log.error("✗ VFS venv 资源不存在");
-            
-            // 检查是否在文件系统中
-            String[] possiblePaths = {
-                "target/classes/org.graalvm.python.vfs/venv",
-                "../parser/target/classes/org.graalvm.python.vfs/venv",
-                "parser/target/classes/org.graalvm.python.vfs/venv"
-            };
-            
-            for (String path : possiblePaths) {
-                File file = new File(path);
-                log.info("Checking file path {}: exists={}", path, file.exists());
-            }
-        }
-        
-        // 4. 尝试创建 Context（不导入任何包）
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            log.info("✓ GraalPyResources Context 创建成功");
-            
-            // 检查 sys.path
-            try {
-                Value sysPath = context.eval("python", """
-                    import sys
-                    list(sys.path)
-                    """);
-                log.info("Python sys.path: {}", sysPath);
-            } catch (Exception e) {
-                log.error("获取 sys.path 失败", e);
-            }
-            
-        } catch (Exception e) {
-            log.error("Context 创建失败", e);
-        }
-    }
-    
-    @Test 
-    public void testDirectVFSPath() {
-        log.info("==== 测试直接指定 VFS 路径 ====");
-        
-        // 检查可能的 VFS 路径
-        String[] vfsPaths = {
-            "target/classes/org.graalvm.python.vfs",
-            "../parser/target/classes/org.graalvm.python.vfs", 
-            "parser/target/classes/org.graalvm.python.vfs"
-        };
-        
-        for (String vfsPath : vfsPaths) {
-            File vfsDir = new File(vfsPath);
-            if (vfsDir.exists()) {
-                log.info("找到 VFS 目录: {}", vfsDir.getAbsolutePath());
-                
-                File venvDir = new File(vfsDir, "venv");
-                File homeDir = new File(vfsDir, "home"); 
-                
-                log.info("  venv 存在: {}", venvDir.exists());
-                log.info("  home 存在: {}", homeDir.exists());
-                
-                if (venvDir.exists()) {
-                    File sitePackages = new File(venvDir, "lib/python3.11/site-packages");
-                    if (sitePackages.exists()) {
-                        log.info("  site-packages 存在: {}", sitePackages.getAbsolutePath());
-                        
-                        File requestsDir = new File(sitePackages, "requests");
-                        log.info("  requests 目录存在: {}", requestsDir.exists());
-                        
-                        if (requestsDir.exists()) {
-                            String[] files = requestsDir.list();
-                            log.info("  requests 目录内容: {}", files != null ? java.util.Arrays.toString(files) : "null");
-                        }
-                    }
-                }
-            } else {
-                log.info("VFS 目录不存在: {}", vfsPath);
-            }
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/GraalPyManualPathTest.java

@@ -1,213 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.graalvm.polyglot.io.IOAccess;
-import org.graalvm.polyglot.HostAccess;
-import org.graalvm.python.embedding.utils.GraalPyResources;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.junit.Assert.*;
-
-/**
- * 手动配置 Python 路径的测试
- */
-public class GraalPyManualPathTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(GraalPyManualPathTest.class);
-    
-    @Test
-    public void testManualPythonPath() {
-        log.info("==== 测试手动配置 Python 路径 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            log.info("Context 创建成功");
-            
-            // 手动添加 site-packages 到 sys.path
-            String addPathScript = """
-                import sys
-                import os
-                
-                # 尝试多个可能的路径
-                possible_paths = [
-                    'target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages',
-                    '../parser/target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages',
-                    'parser/target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages'
-                ]
-                
-                added_paths = []
-                for path in possible_paths:
-                    if os.path.exists(path):
-                        abs_path = os.path.abspath(path)
-                        if abs_path not in sys.path:
-                            sys.path.insert(0, abs_path)
-                            added_paths.append(abs_path)
-                
-                # 也尝试从 classpath 资源路径
-                import importlib.util
-                
-                # 打印当前路径信息
-                print(f"Working directory: {os.getcwd()}")
-                print(f"Python sys.path: {sys.path[:5]}")  # 只打印前5个
-                print(f"Added paths: {added_paths}")
-                
-                len(added_paths)
-                """;
-            
-            Value result = context.eval("python", addPathScript);
-            int addedPaths = result.asInt();
-            log.info("手动添加了 {} 个路径", addedPaths);
-            
-            if (addedPaths > 0) {
-                // 现在尝试导入 requests
-                try {
-                    context.eval("python", "import requests");
-                    log.info("✓ 手动配置路径后 requests 导入成功");
-                    
-                    Value version = context.eval("python", "requests.__version__");
-                    log.info("requests 版本: {}", version.asString());
-                    
-                    assertTrue("requests 应该能够成功导入", true);
-                    
-                } catch (Exception e) {
-                    log.error("即使手动添加路径，requests 导入仍然失败", e);
-                    
-                    // 检查路径中是否有 requests 目录
-                    Value checkDirs = context.eval("python", """
-                        import os
-                        import sys
-                        
-                        found_requests = []
-                        for path in sys.path:
-                            requests_path = os.path.join(path, 'requests')
-                            if os.path.exists(requests_path) and os.path.isdir(requests_path):
-                                found_requests.append(requests_path)
-                        
-                        found_requests
-                        """);
-                    log.info("找到的 requests 目录: {}", checkDirs);
-                    
-                    fail("手动配置路径后仍无法导入 requests: " + e.getMessage());
-                }
-            } else {
-                log.warn("未找到有效的 site-packages 路径，跳过 requests 导入测试");
-            }
-            
-        } catch (Exception e) {
-            log.error("测试失败", e);
-            fail("测试异常: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testRequestsWithAbsolutePath() {
-        log.info("==== 测试使用绝对路径导入 requests ====");
-        
-        // 获取当前工作目录
-        String workDir = System.getProperty("user.dir");
-        log.info("当前工作目录: {}", workDir);
-        
-        // 构造绝对路径
-        String vfsPath = workDir + "/target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages";
-        java.io.File vfsFile = new java.io.File(vfsPath);
-        
-        if (!vfsFile.exists()) {
-            // 尝试上级目录（可能在子模块中运行）
-            vfsPath = workDir + "/../parser/target/classes/org.graalvm.python.vfs/venv/lib/python3.11/site-packages";
-            vfsFile = new java.io.File(vfsPath);
-        }
-        
-        if (!vfsFile.exists()) {
-            log.warn("找不到 VFS site-packages 目录，跳过测试");
-            return;
-        }
-        
-        log.info("使用 VFS 路径: {}", vfsFile.getAbsolutePath());
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            // 直接设置绝对路径
-            context.getBindings("python").putMember("vfs_site_packages", vfsFile.getAbsolutePath());
-            
-            String script = """
-                import sys
-                import os
-                
-                # 添加 VFS site-packages 到 sys.path
-                vfs_path = vfs_site_packages
-                if os.path.exists(vfs_path) and vfs_path not in sys.path:
-                    sys.path.insert(0, vfs_path)
-                    print(f"Added VFS path: {vfs_path}")
-                
-                # 检查 requests 目录
-                requests_dir = os.path.join(vfs_path, 'requests')
-                requests_exists = os.path.exists(requests_dir)
-                print(f"Requests directory exists: {requests_exists}")
-                
-                if requests_exists:
-                    print(f"Requests dir contents: {os.listdir(requests_dir)[:5]}")
-                
-                requests_exists
-                """;
-            
-            Value requestsExists = context.eval("python", script);
-            
-            if (requestsExists.asBoolean()) {
-                log.info("✓ requests 目录存在，尝试导入");
-                
-                try {
-                    context.eval("python", "import requests");
-                    log.info("✓ 使用绝对路径成功导入 requests");
-                    
-                    Value version = context.eval("python", "requests.__version__");
-                    log.info("requests 版本: {}", version.asString());
-                    
-                } catch (Exception e) {
-                    log.error("使用绝对路径导入 requests 失败", e);
-                    
-                    // 获取详细错误信息
-                    try {
-                        Value errorInfo = context.eval("python", """
-                            import sys
-                            import traceback
-                            
-                            try:
-                                import requests
-                            except Exception as e:
-                                error_info = {
-                                    'type': type(e).__name__,
-                                    'message': str(e),
-                                    'traceback': traceback.format_exc()
-                                }
-                                error_info
-                            """);
-                        log.error("Python 导入错误详情: {}", errorInfo);
-                    } catch (Exception te) {
-                        log.error("无法获取 Python 错误详情", te);
-                    }
-                    
-                    throw e;
-                }
-            } else {
-                fail("requests 目录不存在于 VFS 路径中");
-            }
-            
-        } catch (Exception e) {
-            log.error("绝对路径测试失败", e);
-            fail("测试失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/GraalPyPerformanceTest.java

@@ -1,317 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runners.MethodSorters;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-import static org.junit.Assert.*;
-
-/**
- * GraalPy 性能基准测试
- * 验证 Context 池化、路径缓存、预热等优化效果
- * 
- * @author QAIU
- */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class GraalPyPerformanceTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(GraalPyPerformanceTest.class);
-    
-    private static final int WARMUP_ITERATIONS = 2;
-    private static final int TEST_ITERATIONS = 5;
-    
-    private PyContextPool pool;
-    
-    @Before
-    public void setUp() {
-        log.info("========================================");
-        log.info("初始化 PyContextPool...");
-        long start = System.currentTimeMillis();
-        pool = PyContextPool.getInstance();
-        long elapsed = System.currentTimeMillis() - start;
-        log.info("PyContextPool 初始化完成，耗时: {}ms", elapsed);
-        log.info("池状态: {}", pool.getStatus());
-        log.info("========================================");
-    }
-    
-    @After
-    public void tearDown() {
-        log.info("测试完成，池状态: {}", pool.getStatus());
-        log.info("========================================\n");
-    }
-    
-    /**
-     * 测试1：池化 Context 获取性能（预期很快，因为从池中获取）
-     */
-    @Test
-    public void test1_PooledContextAcquirePerformance() throws Exception {
-        log.info("=== 测试1: 池化 Context 获取性能 ===");
-        
-        // 等待预热完成
-        Thread.sleep(2000);
-        
-        List<Long> times = new ArrayList<>();
-        
-        // 预热
-        for (int i = 0; i < WARMUP_ITERATIONS; i++) {
-            try (PyContextPool.PooledContext pc = pool.acquire()) {
-                pc.getContext().eval("python", "1+1");
-            }
-        }
-        
-        // 正式测试
-        for (int i = 0; i < TEST_ITERATIONS; i++) {
-            long start = System.currentTimeMillis();
-            try (PyContextPool.PooledContext pc = pool.acquire()) {
-                pc.getContext().eval("python", "x = 1 + 1");
-            }
-            long elapsed = System.currentTimeMillis() - start;
-            times.add(elapsed);
-            log.info("  迭代 {}: {}ms", i + 1, elapsed);
-        }
-        
-        printStats("池化 Context 获取", times);
-        
-        // 池化获取应该很快（<100ms，因为复用已有 Context）
-        double avg = times.stream().mapToLong(Long::longValue).average().orElse(0);
-        log.info("预期: 池化获取应 < 100ms（复用已有 Context）");
-        assertTrue("池化获取平均耗时应 < 500ms", avg < 500);
-    }
-    
-    /**
-     * 测试2：Fresh Context 创建性能（对比基准）
-     */
-    @Test
-    public void test2_FreshContextCreatePerformance() {
-        log.info("=== 测试2: Fresh Context 创建性能（对比基准）===");
-        
-        List<Long> times = new ArrayList<>();
-        
-        // 正式测试
-        for (int i = 0; i < TEST_ITERATIONS; i++) {
-            long start = System.currentTimeMillis();
-            try (Context ctx = pool.createFreshContext()) {
-                ctx.eval("python", "x = 1 + 1");
-            }
-            long elapsed = System.currentTimeMillis() - start;
-            times.add(elapsed);
-            log.info("  迭代 {}: {}ms", i + 1, elapsed);
-        }
-        
-        printStats("Fresh Context 创建", times);
-        
-        // Fresh 创建通常较慢（~800ms，需要配置路径和验证 requests）
-        log.info("预期: Fresh 创建约 600-1000ms（包含路径配置和 requests 验证）");
-    }
-    
-    /**
-     * 测试3：路径缓存效果验证
-     */
-    @Test
-    public void test3_PathCacheEffectiveness() {
-        log.info("=== 测试3: 路径缓存效果验证 ===");
-        
-        // 第一次创建（会触发路径检测）
-        long start1 = System.currentTimeMillis();
-        try (Context ctx1 = pool.createFreshContext()) {
-            ctx1.eval("python", "import sys; len(sys.path)");
-        }
-        long first = System.currentTimeMillis() - start1;
-        log.info("第一次创建耗时: {}ms（包含路径检测）", first);
-        
-        // 第二次创建（应使用缓存的路径）
-        long start2 = System.currentTimeMillis();
-        try (Context ctx2 = pool.createFreshContext()) {
-            ctx2.eval("python", "import sys; len(sys.path)");
-        }
-        long second = System.currentTimeMillis() - start2;
-        log.info("第二次创建耗时: {}ms（使用路径缓存）", second);
-        
-        // 由于路径缓存，第二次应该更快或相近
-        log.info("路径缓存节省时间: {}ms", first - second);
-    }
-    
-    /**
-     * 测试4：预热 Context 中 requests 导入耗时分解
-     */
-    @Test
-    public void test4_RequestsImportBreakdown() throws Exception {
-        log.info("=== 测试4: requests 导入耗时分解 ===");
-        
-        // 等待预热完成
-        Thread.sleep(2000);
-        
-        try (PyContextPool.PooledContext pc = pool.acquire()) {
-            Context ctx = pc.getContext();
-            
-            // 测试各个依赖包的导入时间
-            String[] packages = {"json", "re", "base64", "hashlib", "urllib.parse"};
-            
-            for (String pkg : packages) {
-                // 清除可能的缓存
-                String testCode = String.format("""
-                    import sys
-                    if '%s' in sys.modules:
-                        del sys.modules['%s']
-                    """, pkg.split("\\.")[0], pkg.split("\\.")[0]);
-                
-                try {
-                    long start = System.currentTimeMillis();
-                    ctx.eval("python", "import " + pkg);
-                    long elapsed = System.currentTimeMillis() - start;
-                    log.info("  导入 {}: {}ms", pkg, elapsed);
-                } catch (Exception e) {
-                    log.warn("  导入 {} 失败: {}", pkg, e.getMessage());
-                }
-            }
-            
-            // 测试 requests（如果在预热的 Context 中已导入，应该很快）
-            long requestsStart = System.currentTimeMillis();
-            try {
-                ctx.eval("python", "import requests; requests.__version__");
-                long elapsed = System.currentTimeMillis() - requestsStart;
-                log.info("  导入 requests: {}ms（预热Context中可能已缓存）", elapsed);
-            } catch (Exception e) {
-                log.warn("  导入 requests 失败（NativeModules限制）: {}", e.getMessage());
-            }
-        }
-    }
-    
-    /**
-     * 测试5：并发获取 Context 性能
-     */
-    @Test
-    public void test5_ConcurrentAcquirePerformance() throws Exception {
-        log.info("=== 测试5: 并发获取 Context 性能 ===");
-        
-        // 等待预热完成
-        Thread.sleep(2000);
-        
-        int threads = 4;
-        int iterations = 8;
-        CountDownLatch latch = new CountDownLatch(threads);
-        AtomicLong totalTime = new AtomicLong(0);
-        AtomicInteger successCount = new AtomicInteger(0);
-        AtomicInteger failCount = new AtomicInteger(0);
-        
-        long overallStart = System.currentTimeMillis();
-        
-        for (int t = 0; t < threads; t++) {
-            final int threadId = t;
-            new Thread(() -> {
-                for (int i = 0; i < iterations / threads; i++) {
-                    long start = System.currentTimeMillis();
-                    try (PyContextPool.PooledContext pc = pool.acquire()) {
-                        pc.getContext().eval("python", "sum(range(100))");
-                        successCount.incrementAndGet();
-                    } catch (Exception e) {
-                        log.error("线程{} 执行失败: {}", threadId, e.getMessage());
-                        failCount.incrementAndGet();
-                    }
-                    totalTime.addAndGet(System.currentTimeMillis() - start);
-                }
-                latch.countDown();
-            }).start();
-        }
-        
-        assertTrue("并发测试应在 60 秒内完成", latch.await(60, TimeUnit.SECONDS));
-        
-        long overallElapsed = System.currentTimeMillis() - overallStart;
-        
-        log.info("并发结果:");
-        log.info("  线程数: {}", threads);
-        log.info("  总请求: {}", iterations);
-        log.info("  成功: {}, 失败: {}", successCount.get(), failCount.get());
-        log.info("  总耗时: {}ms", overallElapsed);
-        log.info("  累计耗时: {}ms", totalTime.get());
-        log.info("  平均每次: {}ms", totalTime.get() / Math.max(1, successCount.get()));
-        log.info("  吞吐量: {} req/s", successCount.get() * 1000.0 / overallElapsed);
-        
-        assertEquals("所有请求应成功", iterations, successCount.get());
-    }
-    
-    /**
-     * 测试6：池化 vs Fresh 对比总结
-     */
-    @Test
-    public void test6_PooledVsFreshComparison() throws Exception {
-        log.info("=== 测试6: 池化 vs Fresh 对比总结 ===");
-        
-        // 等待预热完成（预热在后台线程进行）
-        log.info("等待预热完成...");
-        Thread.sleep(6000);
-        log.info("池状态: {}", pool.getStatus());
-        
-        // 测试池化（从已预热的池中获取）
-        List<Long> pooledTimes = new ArrayList<>();
-        for (int i = 0; i < TEST_ITERATIONS; i++) {
-            long start = System.currentTimeMillis();
-            try (PyContextPool.PooledContext pc = pool.acquire()) {
-                pc.getContext().eval("python", """
-                    def test_func(x):
-                        return x * 2
-                    result = test_func(21)
-                    """);
-            }
-            pooledTimes.add(System.currentTimeMillis() - start);
-        }
-        
-        // 测试 Fresh
-        List<Long> freshTimes = new ArrayList<>();
-        for (int i = 0; i < TEST_ITERATIONS; i++) {
-            long start = System.currentTimeMillis();
-            try (Context ctx = pool.createFreshContext()) {
-                ctx.eval("python", """
-                    def test_func(x):
-                        return x * 2
-                    result = test_func(21)
-                    """);
-            }
-            freshTimes.add(System.currentTimeMillis() - start);
-        }
-        
-        double pooledAvg = pooledTimes.stream().mapToLong(Long::longValue).average().orElse(0);
-        double freshAvg = freshTimes.stream().mapToLong(Long::longValue).average().orElse(0);
-        
-        log.info("对比结果:");
-        log.info("  池化时间: {}", pooledTimes);
-        log.info("  Fresh时间: {}", freshTimes);
-        log.info("  池化平均: {}ms", String.format("%.2f", pooledAvg));
-        log.info("  Fresh平均: {}ms", String.format("%.2f", freshAvg));
-        
-        if (freshAvg > pooledAvg) {
-            log.info("  性能提升: {}x", String.format("%.2f", freshAvg / Math.max(1, pooledAvg)));
-            log.info("  节省时间: {}ms ({}%)", 
-                    String.format("%.2f", freshAvg - pooledAvg),
-                    String.format("%.1f", (freshAvg - pooledAvg) / freshAvg * 100));
-        } else {
-            log.info("  注意: 池化未显著提升（可能预热未完成或测试环境因素）");
-        }
-        
-        // 放宽断言：只要池化不比 Fresh 慢太多即可（允许 20% 误差）
-        assertTrue("池化应不比 Fresh 慢很多", pooledAvg <= freshAvg * 1.2);
-    }
-    
-    private void printStats(String name, List<Long> times) {
-        double avg = times.stream().mapToLong(Long::longValue).average().orElse(0);
-        long min = times.stream().mapToLong(Long::longValue).min().orElse(0);
-        long max = times.stream().mapToLong(Long::longValue).max().orElse(0);
-        
-        log.info("{} 统计:", name);
-        log.info("  平均: {}ms", String.format("%.2f", avg));
-        log.info("  最小: {}ms", min);
-        log.info("  最大: {}ms", max);
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/GraalPyPipTest.java

@@ -1,293 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.graalvm.polyglot.io.IOAccess;
-import org.graalvm.polyglot.HostAccess;
-import org.graalvm.python.embedding.utils.GraalPyResources;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.junit.Assert.*;
-
-/**
- * GraalPy pip 包测试
- * 验证 requests 等 pip 包是否能正常加载和使用
- */
-public class GraalPyPipTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(GraalPyPipTest.class);
-    
-    @Test
-    public void testGraalPyResourcesAvailability() {
-        log.info("==== 测试 GraalPy VFS 资源可用性 ====");
-        
-        // 检查 VFS 资源是否存在
-        var vfsVenv = getClass().getClassLoader().getResource("org.graalvm.python.vfs/venv");
-        var vfsHome = getClass().getClassLoader().getResource("org.graalvm.python.vfs/home");
-        
-        log.info("VFS venv 资源: {}", vfsVenv);
-        log.info("VFS home 资源: {}", vfsHome);
-        
-        assertNotNull("VFS venv 资源应该存在", vfsVenv);
-        assertNotNull("VFS home 资源应该存在", vfsHome);
-        
-        log.info("✓ VFS 资源检查通过");
-    }
-    
-    @Test
-    public void testGraalPyContextCreation() {
-        log.info("==== 测试 GraalPyResources Context 创建 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            log.info("✓ GraalPyResources Context 创建成功");
-            
-            // 测试基本 Python 功能
-            Value result = context.eval("python", "2 + 3");
-            assertEquals("Python 基本计算", 5, result.asInt());
-            
-            log.info("✓ Python 基本功能正常");
-            
-        } catch (Exception e) {
-            log.error("GraalPyResources Context 创建失败", e);
-            fail("Context 创建失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPythonBuiltinModules() {
-        log.info("==== 测试 Python 内置模块 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            // 测试基本内置模块
-            context.eval("python", "import sys");
-            context.eval("python", "import os");
-            context.eval("python", "import json");
-            context.eval("python", "import re");
-            context.eval("python", "import time");
-            context.eval("python", "import random");
-            
-            log.info("✓ Python 内置模块导入成功");
-            
-        } catch (Exception e) {
-            log.error("Python 内置模块测试失败", e);
-            fail("内置模块导入失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testRequestsImport() {
-        log.info("==== 测试 requests 包导入 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            // 首先检查 sys.path
-            Value sysPath = context.eval("python", """
-                import sys
-                sys.path
-                """);
-            log.info("Python sys.path: {}", sysPath);
-            
-            // 检查 site-packages 是否在路径中
-            Value sitePackagesCheck = context.eval("python", """
-                import sys
-                [p for p in sys.path if 'site-packages' in p]
-                """);
-            log.info("site-packages 路径: {}", sitePackagesCheck);
-            
-            try {
-                // 测试 requests 导入
-                context.eval("python", "import requests");
-                log.info("✓ requests 包导入成功");
-                
-                // 获取 requests 版本
-                Value version = context.eval("python", "requests.__version__");
-                String requestsVersion = version.asString();
-                log.info("requests 版本: {}", requestsVersion);
-                assertNotNull("requests 版本不应为空", requestsVersion);
-                
-                // 测试 requests 相关依赖
-                context.eval("python", "import urllib3");
-                context.eval("python", "import certifi");
-                context.eval("python", "import charset_normalizer");
-                context.eval("python", "import idna");
-                
-                log.info("✓ requests 相关依赖导入成功");
-                
-            } catch (Exception importError) {
-                log.error("requests 导入异常详情:", importError);
-                
-                // 尝试列出可用的模块
-                try {
-                    Value availableModules = context.eval("python", """
-                        import pkgutil
-                        [name for importer, name, ispkg in pkgutil.iter_modules()][:20]
-                        """);
-                    log.info("可用模块（前20个）: {}", availableModules);
-                } catch (Exception e) {
-                    log.error("无法列出可用模块", e);
-                }
-                
-                throw importError;
-            }
-            
-        } catch (Exception e) {
-            log.error("requests 包测试失败", e);
-            if (e.getCause() != null) {
-                log.error("原因:", e.getCause());
-            }
-            fail("requests 导入失败: " + (e.getMessage() != null ? e.getMessage() : e.getClass().getName()));
-        }
-    }
-    
-    @Test
-    public void testRequestsBasicFunctionality() {
-        log.info("==== 测试 requests 基本功能 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            // 测试 requests 基本 API
-            String pythonCode = """
-                import requests
-                
-                # 测试 Session 创建
-                session = requests.Session()
-                
-                # 测试基本 API 存在性
-                assert hasattr(requests, 'get')
-                assert hasattr(requests, 'post')
-                assert hasattr(requests, 'put')
-                assert hasattr(requests, 'delete')
-                
-                # 测试 Response 类
-                assert hasattr(requests, 'Response')
-                
-                result = "requests API 检查通过"
-                """;
-            
-            context.eval("python", pythonCode);
-            Value result = context.eval("python", "result");
-            assertEquals("requests API 检查通过", result.asString());
-            
-            log.info("✓ requests 基本 API 功能正常");
-            
-        } catch (Exception e) {
-            log.error("requests 基本功能测试失败", e);
-            fail("requests 基本功能测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testPyContextPoolIntegration() {
-        log.info("==== 测试 PyContextPool 集成 ====");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            log.info("✓ PyContextPool.createFreshContext() 成功");
-            
-            // 测试 requests 导入
-            context.eval("python", "import requests");
-            log.info("✓ 通过 PyContextPool 创建的 Context 可以导入 requests");
-            
-            // 注入测试对象
-            Value bindings = context.getBindings("python");
-            bindings.putMember("test_message", "Hello from Java");
-            
-            Value result = context.eval("python", "test_message + ' to Python'");
-            assertEquals("Hello from Java to Python", result.asString());
-            
-            log.info("✓ Java 对象注入正常");
-            
-        } catch (Exception e) {
-            log.error("PyContextPool 集成测试失败", e);
-            fail("PyContextPool 集成测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testComplexPythonScript() {
-        log.info("==== 测试复杂 Python 脚本 ====");
-        
-        try (Context context = GraalPyResources.contextBuilder()
-                .allowIO(IOAccess.ALL)
-                .allowNativeAccess(true)
-                .allowHostAccess(HostAccess.ALL)
-                .option("engine.WarnInterpreterOnly", "false")
-                .build()) {
-            
-            String complexScript = """
-                import requests
-                import json
-                import re
-                import sys
-                import time
-                import random
-                
-                def test_function():
-                    # 测试各种 Python 功能
-                    data = {
-                        'requests_version': requests.__version__,
-                        'python_version': sys.version,
-                        'random_number': random.randint(1, 100),
-                        'current_time': time.time()
-                    }
-                    
-                    # 测试 JSON 序列化
-                    json_str = json.dumps(data)
-                    parsed_data = json.loads(json_str)
-                    
-                    # 测试正则表达式
-                    version_match = re.search(r'(\\d+\\.\\d+\\.\\d+)', parsed_data['requests_version'])
-                    
-                    return {
-                        'success': True,
-                        'requests_version': parsed_data['requests_version'],
-                        'version_match': version_match is not None,
-                        'data_count': len(parsed_data)
-                    }
-                
-                # 执行测试
-                result = test_function()
-                """;
-            
-            context.eval("python", complexScript);
-            Value result = context.eval("python", "result");
-            
-            assertTrue("脚本执行应该成功", result.getMember("success").asBoolean());
-            assertNotNull("requests 版本应该存在", result.getMember("requests_version").asString());
-            assertTrue("版本匹配应该成功", result.getMember("version_match").asBoolean());
-            assertEquals("数据项数量应该为4", 4, result.getMember("data_count").asInt());
-            
-            log.info("✓ 复杂 Python 脚本执行成功");
-            log.info("requests 版本: {}", result.getMember("requests_version").asString());
-            
-        } catch (Exception e) {
-            log.error("复杂 Python 脚本测试失败", e);
-            fail("复杂脚本执行失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/PlaygroundApiTest.java

@@ -1,451 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-import io.vertx.core.Vertx;
-import io.vertx.core.buffer.Buffer;
-import io.vertx.core.http.HttpClient;
-import io.vertx.core.http.HttpClientOptions;
-import io.vertx.core.http.HttpMethod;
-import io.vertx.core.json.JsonObject;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * PlaygroundApi 接口测试
- * 测试 /v2/playground/* API 端点
- * 
- * 注意：这个测试需要后端服务运行中
- * 默认测试地址: http://localhost:8080
- */
-public class PlaygroundApiTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(PlaygroundApiTest.class);
-    
-    // 测试服务器配置
-    private static final String HOST = "localhost";
-    private static final int PORT = 8080;
-    private static final int TIMEOUT_SECONDS = 30;
-    
-    private final Vertx vertx;
-    private final HttpClient client;
-    
-    // 测试统计
-    private int totalTests = 0;
-    private int passedTests = 0;
-    private int failedTests = 0;
-    
-    public PlaygroundApiTest() {
-        this.vertx = Vertx.vertx();
-        this.client = vertx.createHttpClient(new HttpClientOptions()
-            .setDefaultHost(HOST)
-            .setDefaultPort(PORT)
-            .setConnectTimeout(10000)
-            .setIdleTimeout(TIMEOUT_SECONDS));
-    }
-    
-    /**
-     * 测试 GET /v2/playground/status
-     */
-    public void testGetStatus() {
-        totalTests++;
-        log.info("=== 测试1: GET /v2/playground/status ===");
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Boolean> success = new AtomicReference<>(false);
-        AtomicReference<String> error = new AtomicReference<>();
-        
-        client.request(HttpMethod.GET, "/v2/playground/status")
-            .compose(req -> req.send())
-            .compose(resp -> {
-                log.info("  状态码: {}", resp.statusCode());
-                return resp.body();
-            })
-            .onSuccess(body -> {
-                try {
-                    JsonObject json = new JsonObject(body.toString());
-                    log.info("  响应: {}", json.encodePrettily());
-                    
-                    // 验证响应结构
-                    if (json.containsKey("code") && json.containsKey("data")) {
-                        JsonObject data = json.getJsonObject("data");
-                        if (data.containsKey("enabled")) {
-                            success.set(true);
-                            log.info("  ✓ 状态接口正常，enabled={}", data.getBoolean("enabled"));
-                        }
-                    }
-                } catch (Exception e) {
-                    error.set("解析响应失败: " + e.getMessage());
-                }
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                error.set("请求失败: " + e.getMessage());
-                latch.countDown();
-            });
-        
-        try {
-            latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            error.set("超时");
-        }
-        
-        if (success.get()) {
-            passedTests++;
-        } else {
-            failedTests++;
-            log.error("  ✗ 测试失败: {}", error.get());
-        }
-    }
-    
-    /**
-     * 测试 POST /v2/playground/test - JavaScript代码执行
-     */
-    public void testJavaScriptExecution() {
-        totalTests++;
-        log.info("=== 测试2: POST /v2/playground/test (JavaScript) ===");
-        
-        String jsCode = """
-            // @name 测试解析器
-            // @match https?://example\\.com/s/(?<KEY>\\w+)
-            // @type test_js
-            
-            function parse(shareLinkInfo, http, logger) {
-                logger.info("开始解析...");
-                var url = shareLinkInfo.getShareUrl();
-                logger.info("URL: " + url);
-                return "https://download.example.com/test.zip";
-            }
-            """;
-        
-        JsonObject requestBody = new JsonObject()
-            .put("code", jsCode)
-            .put("shareUrl", "https://example.com/s/abc123")
-            .put("language", "javascript")
-            .put("method", "parse");
-        
-        executeTestRequest(requestBody, "JavaScript");
-    }
-    
-    /**
-     * 测试 POST /v2/playground/test - Python代码执行
-     */
-    public void testPythonExecution() {
-        totalTests++;
-        log.info("=== 测试3: POST /v2/playground/test (Python) ===");
-        
-        String pyCode = """
-            # @name 测试解析器
-            # @match https?://example\\.com/s/(?P<KEY>\\w+)
-            # @type test_py
-            
-            import json
-            
-            def parse(share_link_info, http, logger):
-                logger.info("开始解析...")
-                url = share_link_info.get_share_url()
-                logger.info(f"URL: {url}")
-                return "https://download.example.com/test.zip"
-            """;
-        
-        JsonObject requestBody = new JsonObject()
-            .put("code", pyCode)
-            .put("shareUrl", "https://example.com/s/abc123")
-            .put("language", "python")
-            .put("method", "parse");
-        
-        executeTestRequest(requestBody, "Python");
-    }
-    
-    /**
-     * 测试 POST /v2/playground/test - 安全检查拦截
-     */
-    public void testSecurityBlock() {
-        totalTests++;
-        log.info("=== 测试4: POST /v2/playground/test (安全检查拦截) ===");
-        
-        String dangerousCode = """
-            # @name 危险解析器
-            # @match https?://example\\.com/s/(?P<KEY>\\w+)
-            # @type dangerous
-            
-            import subprocess
-            
-            def parse(share_link_info, http, logger):
-                result = subprocess.run(['ls'], capture_output=True)
-                return result.stdout.decode()
-            """;
-        
-        JsonObject requestBody = new JsonObject()
-            .put("code", dangerousCode)
-            .put("shareUrl", "https://example.com/s/abc123")
-            .put("language", "python")
-            .put("method", "parse");
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Boolean> success = new AtomicReference<>(false);
-        AtomicReference<String> error = new AtomicReference<>();
-        
-        client.request(HttpMethod.POST, "/v2/playground/test")
-            .compose(req -> {
-                req.putHeader("Content-Type", "application/json");
-                return req.send(requestBody.encode());
-            })
-            .compose(resp -> {
-                log.info("  状态码: {}", resp.statusCode());
-                return resp.body();
-            })
-            .onSuccess(body -> {
-                try {
-                    JsonObject json = new JsonObject(body.toString());
-                    log.info("  响应: {}", json.encodePrettily().substring(0, Math.min(500, json.encodePrettily().length())));
-                    
-                    // 危险代码应该被拦截，success=false
-                    JsonObject data = json.getJsonObject("data");
-                    if (data != null && !data.getBoolean("success", true)) {
-                        String errorMsg = data.getString("error", "");
-                        if (errorMsg.contains("安全检查") || errorMsg.contains("subprocess")) {
-                            success.set(true);
-                            log.info("  ✓ 安全检查正确拦截了危险代码");
-                        }
-                    }
-                } catch (Exception e) {
-                    error.set("解析响应失败: " + e.getMessage());
-                }
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                error.set("请求失败: " + e.getMessage());
-                latch.countDown();
-            });
-        
-        try {
-            latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            error.set("超时");
-        }
-        
-        if (success.get()) {
-            passedTests++;
-        } else {
-            failedTests++;
-            log.error("  ✗ 测试失败: {}", error.get());
-        }
-    }
-    
-    /**
-     * 测试 POST /v2/playground/test - 缺少参数
-     */
-    public void testMissingParameters() {
-        totalTests++;
-        log.info("=== 测试5: POST /v2/playground/test (缺少参数) ===");
-        
-        JsonObject requestBody = new JsonObject()
-            .put("shareUrl", "https://example.com/s/abc123")
-            .put("language", "javascript")
-            .put("method", "parse");
-        // 缺少 code 字段
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Boolean> success = new AtomicReference<>(false);
-        AtomicReference<String> error = new AtomicReference<>();
-        
-        client.request(HttpMethod.POST, "/v2/playground/test")
-            .compose(req -> {
-                req.putHeader("Content-Type", "application/json");
-                return req.send(requestBody.encode());
-            })
-            .compose(resp -> {
-                log.info("  状态码: {}", resp.statusCode());
-                return resp.body();
-            })
-            .onSuccess(body -> {
-                try {
-                    JsonObject json = new JsonObject(body.toString());
-                    log.info("  响应: {}", json.encodePrettily());
-                    
-                    // 缺少参数应该返回错误
-                    JsonObject data = json.getJsonObject("data");
-                    if (data != null && !data.getBoolean("success", true)) {
-                        String errorMsg = data.getString("error", "");
-                        if (errorMsg.contains("代码不能为空") || errorMsg.contains("empty") || errorMsg.contains("required")) {
-                            success.set(true);
-                            log.info("  ✓ 正确返回了参数缺失错误");
-                        }
-                    }
-                } catch (Exception e) {
-                    error.set("解析响应失败: " + e.getMessage());
-                }
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                error.set("请求失败: " + e.getMessage());
-                latch.countDown();
-            });
-        
-        try {
-            latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            error.set("超时");
-        }
-        
-        if (success.get()) {
-            passedTests++;
-        } else {
-            failedTests++;
-            log.error("  ✗ 测试失败: {}", error.get());
-        }
-    }
-    
-    /**
-     * 执行测试请求
-     */
-    private void executeTestRequest(JsonObject requestBody, String languageName) {
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Boolean> success = new AtomicReference<>(false);
-        AtomicReference<String> error = new AtomicReference<>();
-        
-        client.request(HttpMethod.POST, "/v2/playground/test")
-            .compose(req -> {
-                req.putHeader("Content-Type", "application/json");
-                return req.send(requestBody.encode());
-            })
-            .compose(resp -> {
-                log.info("  状态码: {}", resp.statusCode());
-                return resp.body();
-            })
-            .onSuccess(body -> {
-                try {
-                    JsonObject json = new JsonObject(body.toString());
-                    String prettyJson = json.encodePrettily();
-                    log.info("  响应: {}", prettyJson.substring(0, Math.min(800, prettyJson.length())));
-                    
-                    // 检查响应结构
-                    JsonObject data = json.getJsonObject("data");
-                    if (data != null) {
-                        boolean testSuccess = data.getBoolean("success", false);
-                        if (testSuccess) {
-                            Object result = data.getValue("result");
-                            log.info("  ✓ {} 代码执行成功，结果: {}", languageName, result);
-                            success.set(true);
-                        } else {
-                            String errorMsg = data.getString("error", "未知错误");
-                            log.warn("  执行失败: {}", errorMsg);
-                            // 某些预期的执行失败也算测试通过（如 URL 匹配失败等）
-                            if (errorMsg.contains("不匹配") || errorMsg.contains("match")) {
-                                success.set(true);
-                                log.info("  ✓ 接口正常工作（URL 匹配规则验证正常）");
-                            }
-                        }
-                    }
-                } catch (Exception e) {
-                    error.set("解析响应失败: " + e.getMessage());
-                }
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                error.set("请求失败: " + e.getMessage());
-                latch.countDown();
-            });
-        
-        try {
-            latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            error.set("超时");
-        }
-        
-        if (success.get()) {
-            passedTests++;
-        } else {
-            failedTests++;
-            log.error("  ✗ 测试失败: {}", error.get());
-        }
-    }
-    
-    /**
-     * 关闭客户端
-     */
-    public void close() {
-        client.close();
-        vertx.close();
-    }
-    
-    /**
-     * 运行所有测试
-     */
-    public void runAll() {
-        log.info("======================================");
-        log.info("   PlaygroundApi 接口测试");
-        log.info("   测试服务器: http://{}:{}", HOST, PORT);
-        log.info("======================================\n");
-        
-        // 先检查服务是否可用
-        if (!checkServerAvailable()) {
-            log.error("❌ 服务器不可用，请先启动后端服务！");
-            log.info("\n提示：可以使用以下命令启动服务：");
-            log.info("  cd web-service && mvn exec:java -Dexec.mainClass=cn.qaiu.lz.AppMain");
-            return;
-        }
-        
-        log.info("✓ 服务器连接正常\n");
-        
-        // 执行测试
-        testGetStatus();
-        testJavaScriptExecution();
-        testPythonExecution();
-        testSecurityBlock();
-        testMissingParameters();
-        
-        // 输出结果
-        log.info("\n======================================");
-        log.info("             测试结果");
-        log.info("======================================");
-        log.info("总测试数: {}", totalTests);
-        log.info("通过: {}", passedTests);
-        log.info("失败: {}", failedTests);
-        
-        if (failedTests == 0) {
-            log.info("\n✅ 所有接口测试通过!");
-        } else {
-            log.error("\n❌ {} 个测试失败", failedTests);
-        }
-        
-        close();
-    }
-    
-    /**
-     * 检查服务器是否可用
-     */
-    private boolean checkServerAvailable() {
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Boolean> available = new AtomicReference<>(false);
-        
-        client.request(HttpMethod.GET, "/v2/playground/status")
-            .compose(req -> req.send())
-            .onSuccess(resp -> {
-                available.set(resp.statusCode() == 200);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                log.debug("服务器连接失败: {}", e.getMessage());
-                latch.countDown();
-            });
-        
-        try {
-            latch.await(5, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            // 忽略
-        }
-        
-        return available.get();
-    }
-    
-    public static void main(String[] args) {
-        PlaygroundApiTest test = new PlaygroundApiTest();
-        test.runAll();
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/PyCodeSecurityCheckerTest.java

@@ -1,235 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-/**
- * Python 代码安全检查器测试
- */
-public class PyCodeSecurityCheckerTest {
-    
-    @Test
-    public void testSafeCode() {
-        String code = """
-            import requests
-            import json
-            import re
-            
-            def parse(share_info, http, logger):
-                response = requests.get(share_info.shareUrl)
-                return response.text
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertTrue("安全代码应该通过检查", result.isPassed());
-    }
-    
-    @Test
-    public void testDangerousImport_subprocess() {
-        String code = """
-            import subprocess
-            
-            def parse(share_info, http, logger):
-                result = subprocess.run(['ls', '-la'], capture_output=True)
-                return result.stdout
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("导入 subprocess 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("subprocess"));
-    }
-    
-    @Test
-    public void testDangerousImport_socket() {
-        String code = """
-            import socket
-            
-            def parse(share_info, http, logger):
-                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("导入 socket 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("socket"));
-    }
-    
-    @Test
-    public void testDangerousOsMethod_system() {
-        String code = """
-            import os
-            
-            def parse(share_info, http, logger):
-                os.system('rm -rf /')
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("os.system 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("os.system"));
-    }
-    
-    @Test
-    public void testDangerousOsMethod_popen() {
-        String code = """
-            import os
-            
-            def parse(share_info, http, logger):
-                result = os.popen('whoami').read()
-                return result
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("os.popen 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("os.popen"));
-    }
-    
-    @Test
-    public void testDangerousBuiltin_exec() {
-        String code = """
-            def parse(share_info, http, logger):
-                exec('print("hacked")')
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("exec() 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("exec"));
-    }
-    
-    @Test
-    public void testDangerousBuiltin_eval() {
-        String code = """
-            def parse(share_info, http, logger):
-                result = eval('1+1')
-                return str(result)
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("eval() 应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("eval"));
-    }
-    
-    @Test
-    public void testSafeOsUsage_environ() {
-        // os.environ 是安全的，应该允许
-        String code = """
-            import os
-            
-            def parse(share_info, http, logger):
-                path = os.environ.get('PATH', '')
-                return path
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertTrue("os.environ 应该是允许的", result.isPassed());
-    }
-    
-    @Test
-    public void testSafeOsUsage_path() {
-        // os.path 是安全的
-        String code = """
-            import os
-            
-            def parse(share_info, http, logger):
-                base = os.path.basename('/tmp/test.txt')
-                return base
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertTrue("os.path 方法应该是允许的", result.isPassed());
-    }
-    
-    @Test
-    public void testDangerousFileWrite() {
-        String code = """
-            def parse(share_info, http, logger):
-                with open('/tmp/hack.txt', 'w') as f:
-                    f.write('hacked')
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("文件写入应该被禁止", result.isPassed());
-        assertTrue(result.getMessage().contains("文件"));
-    }
-    
-    @Test
-    public void testSafeFileRead() {
-        // 读取文件应该是允许的（实际上 GraalPy sandbox 会限制文件系统访问）
-        String code = """
-            def parse(share_info, http, logger):
-                with open('/tmp/test.txt', 'r') as f:
-                    content = f.read()
-                return content
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        // 这里只做静态检查，读取模式 'r' 应该通过
-        assertTrue("文件读取应该是允许的", result.isPassed());
-    }
-    
-    @Test
-    public void testEmptyCode() {
-        var result = PyCodeSecurityChecker.check("");
-        assertFalse("空代码应该失败", result.isPassed());
-    }
-    
-    @Test
-    public void testNullCode() {
-        var result = PyCodeSecurityChecker.check(null);
-        assertFalse("null 代码应该失败", result.isPassed());
-    }
-    
-    @Test
-    public void testMultipleViolations() {
-        String code = """
-            import subprocess
-            import socket
-            import os
-            
-            def parse(share_info, http, logger):
-                os.system('ls')
-                exec('print("hack")')
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("多个违规应该被检测到", result.isPassed());
-        // 检查消息中包含多个违规项
-        String message = result.getMessage();
-        assertTrue(message.contains("subprocess"));
-        assertTrue(message.contains("socket"));
-        assertTrue(message.contains("os.system"));
-        assertTrue(message.contains("exec"));
-    }
-    
-    @Test
-    public void testFromImport() {
-        String code = """
-            from subprocess import run
-            
-            def parse(share_info, http, logger):
-                return "test"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertFalse("from subprocess import 应该被禁止", result.isPassed());
-    }
-    
-    @Test
-    public void testRequestsWrite() {
-        // 使用 requests 的 response 写入应该允许
-        String code = """
-            import requests
-            
-            def parse(share_info, http, logger):
-                response = requests.get('http://example.com')
-                # 这不是真正的文件写入
-                return response.text
-            """;
-        
-        var result = PyCodeSecurityChecker.check(code);
-        assertTrue("requests 使用应该是允许的", result.isPassed());
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/PyPlaygroundFullTest.java

@@ -1,468 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.Assert.*;
-
-/**
- * Python 演练场完整单元测试
- * 测试 GraalPy 环境、代码执行、安全检查等功能
- */
-public class PyPlaygroundFullTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyPlaygroundFullTest.class);
-    
-    @BeforeClass
-    public static void setup() {
-        log.info("初始化 PyContextPool...");
-        PyContextPool.getInstance();
-    }
-    
-    // ========== 基础功能测试 ==========
-    
-    @Test
-    public void testBasicPythonExecution() {
-        log.info("=== 测试1: 基础 Python 执行 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试简单表达式
-            Value result = context.eval("python", "1 + 2");
-            assertEquals(3, result.asInt());
-            log.info("✓ 基础表达式: 1 + 2 = {}", result.asInt());
-            
-            // 测试字符串操作
-            Value strResult = context.eval("python", "'hello'.upper()");
-            assertEquals("HELLO", strResult.asString());
-            log.info("✓ 字符串操作: 'hello'.upper() = {}", strResult.asString());
-        }
-    }
-    
-    /**
-     * 测试 requests 库导入
-     * 注意：由于 GraalPy 的 unicodedata/LLVM 限制，requests 只能在第一个 Context 中导入
-     * 后续创建的 Context 导入 requests 会失败
-     * 这个测试标记为跳过，实际导入功能由测试13（前端模板代码）验证
-     */
-    @Test
-    public void testRequestsImport() throws Exception {
-        log.info("=== 测试2: requests 库导入 ===");
-        log.info("⚠️ 注意：由于 GraalPy unicodedata/LLVM 限制，此测试跳过");
-        log.info("  requests 导入功能已在测试13（前端模板代码）中验证通过");
-        log.info("✓ 测试跳过（已知限制）");
-        // 此测试跳过，实际功能由前端模板代码测试覆盖
-    }
-    
-    @Test
-    public void testStandardLibraries() {
-        log.info("=== 测试3: 标准库导入 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // json
-            context.eval("python", "import json");
-            Value jsonResult = context.eval("python", "json.dumps({'a': 1})");
-            assertEquals("{\"a\": 1}", jsonResult.asString());
-            log.info("✓ json 库正常");
-            
-            // re
-            context.eval("python", "import re");
-            Value reResult = context.eval("python", "bool(re.match(r'\\d+', '123'))");
-            assertTrue(reResult.asBoolean());
-            log.info("✓ re 库正常");
-            
-            // base64
-            context.eval("python", "import base64");
-            Value b64Result = context.eval("python", "base64.b64encode(b'hello').decode()");
-            assertEquals("aGVsbG8=", b64Result.asString());
-            log.info("✓ base64 库正常");
-            
-            // hashlib
-            context.eval("python", "import hashlib");
-            Value md5Result = context.eval("python", "hashlib.md5(b'hello').hexdigest()");
-            assertEquals("5d41402abc4b2a76b9719d911017c592", md5Result.asString());
-            log.info("✓ hashlib 库正常");
-        }
-    }
-    
-    // ========== parse 函数测试 ==========
-    
-    @Test
-    public void testSimpleParseFunction() {
-        log.info("=== 测试4: 简单 parse 函数 ===");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                logger.info("测试开始")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            PyPlaygroundLogger logger = new PyPlaygroundLogger();
-            
-            Value bindings = context.getBindings("python");
-            bindings.putMember("logger", logger);
-            
-            context.eval("python", pyCode);
-            
-            Value parseFunc = bindings.getMember("parse");
-            assertNotNull("parse 函数应该存在", parseFunc);
-            assertTrue("parse 应该可执行", parseFunc.canExecute());
-            
-            Value result = parseFunc.execute(null, null, logger);
-            assertEquals("https://example.com/download/test.zip", result.asString());
-            log.info("✓ parse 函数执行成功: {}", result.asString());
-            
-            assertFalse("应该有日志", logger.getLogs().isEmpty());
-            log.info("✓ 日志记录数: {}", logger.getLogs().size());
-        }
-    }
-    
-    /**
-     * 测试带 requests 的 parse 函数
-     * 注意：由于 GraalPy 限制，此测试跳过
-     * 功能已在测试13（前端模板代码）中验证
-     */
-    @Test
-    public void testParseWithRequests() throws Exception {
-        log.info("=== 测试5: 带 requests 的 parse 函数 ===");
-        log.info("⚠️ 注意：由于 GraalPy unicodedata/LLVM 限制，此测试跳过");
-        log.info("  此功能已在测试13（前端模板代码）中验证通过");
-        log.info("✓ 测试跳过（已知限制）");
-    }
-    
-    @Test
-    public void testParseWithShareLinkInfo() {
-        log.info("=== 测试6: 带 share_link_info 的 parse 函数 ===");
-        
-        String pyCode = """
-            import json
-            
-            def parse(share_link_info, http, logger):
-                url = share_link_info.get_share_url()
-                key = share_link_info.get_share_key()
-                logger.info(f"URL: {url}, Key: {key}")
-                return f"https://download.example.com/{key}/file.zip"
-            """;
-        
-        ShareLinkInfo shareLinkInfo = ShareLinkInfo.newBuilder()
-            .shareUrl("https://example.com/s/abc123")
-            .shareKey("abc123")
-            .build();
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            PyPlaygroundLogger logger = new PyPlaygroundLogger();
-            PyShareLinkInfoWrapper wrapper = new PyShareLinkInfoWrapper(shareLinkInfo);
-            
-            Value bindings = context.getBindings("python");
-            bindings.putMember("logger", logger);
-            bindings.putMember("share_link_info", wrapper);
-            
-            context.eval("python", pyCode);
-            
-            Value parseFunc = bindings.getMember("parse");
-            Value result = parseFunc.execute(wrapper, null, logger);
-            
-            assertEquals("https://download.example.com/abc123/file.zip", result.asString());
-            log.info("✓ 带 share_link_info 的 parse 执行成功: {}", result.asString());
-        }
-    }
-    
-    // ========== PyPlaygroundExecutor 测试 ==========
-    
-    @Test
-    public void testPyPlaygroundExecutor() throws Exception {
-        log.info("=== 测试7: PyPlaygroundExecutor ===");
-        
-        String pyCode = """
-            import json
-            
-            def parse(share_link_info, http, logger):
-                url = share_link_info.get_share_url()
-                logger.info(f"解析链接: {url}")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        assertTrue("执行应在30秒内完成", latch.await(30, TimeUnit.SECONDS));
-        
-        if (errorRef.get() != null) {
-            log.error("执行失败", errorRef.get());
-            fail("执行失败: " + errorRef.get().getMessage());
-        }
-        
-        assertEquals("https://example.com/download/test.zip", resultRef.get());
-        log.info("✓ PyPlaygroundExecutor 执行成功: {}", resultRef.get());
-        
-        log.info("  执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("    [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-    
-    // ========== 安全检查测试 ==========
-    
-    @Test
-    public void testSecurityCheckerBlocksSubprocess() throws Exception {
-        log.info("=== 测试8: 安全检查 - 拦截 subprocess ===");
-        
-        String dangerousCode = """
-            import subprocess
-            
-            def parse(share_link_info, http, logger):
-                result = subprocess.run(['ls'], capture_output=True)
-                return result.stdout.decode()
-            """;
-        
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, dangerousCode);
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> latch.countDown())
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        assertTrue("执行应在30秒内完成", latch.await(30, TimeUnit.SECONDS));
-        
-        assertNotNull("应该抛出异常", errorRef.get());
-        assertTrue("应该是安全检查失败", 
-            errorRef.get().getMessage().contains("安全检查") || 
-            errorRef.get().getMessage().contains("subprocess"));
-        
-        log.info("✓ 正确拦截 subprocess: {}", errorRef.get().getMessage());
-    }
-    
-    @Test
-    public void testSecurityCheckerBlocksSocket() throws Exception {
-        log.info("=== 测试9: 安全检查 - 拦截 socket ===");
-        
-        String dangerousCode = """
-            import socket
-            
-            def parse(share_link_info, http, logger):
-                s = socket.socket()
-                return "hacked"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(dangerousCode);
-        assertFalse("应该检查失败", result.isPassed());
-        assertTrue("应该包含 socket", result.getMessage().contains("socket"));
-        log.info("✓ 正确拦截 socket: {}", result.getMessage());
-    }
-    
-    @Test
-    public void testSecurityCheckerBlocksOsSystem() throws Exception {
-        log.info("=== 测试10: 安全检查 - 拦截 os.system ===");
-        
-        String dangerousCode = """
-            import os
-            
-            def parse(share_link_info, http, logger):
-                os.system("rm -rf /")
-                return "hacked"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(dangerousCode);
-        assertFalse("应该检查失败", result.isPassed());
-        assertTrue("应该包含 os.system", result.getMessage().contains("os.system"));
-        log.info("✓ 正确拦截 os.system: {}", result.getMessage());
-    }
-    
-    @Test
-    public void testSecurityCheckerBlocksExec() throws Exception {
-        log.info("=== 测试11: 安全检查 - 拦截 exec/eval ===");
-        
-        String dangerousCode = """
-            def parse(share_link_info, http, logger):
-                exec("import os; os.system('rm -rf /')")
-                return "hacked"
-            """;
-        
-        var result = PyCodeSecurityChecker.check(dangerousCode);
-        assertFalse("应该检查失败", result.isPassed());
-        assertTrue("应该包含 exec", result.getMessage().contains("exec"));
-        log.info("✓ 正确拦截 exec: {}", result.getMessage());
-    }
-    
-    @Test
-    public void testSecurityCheckerAllowsSafeCode() {
-        log.info("=== 测试12: 安全检查 - 允许安全代码 ===");
-        
-        String safeCode = """
-            import requests
-            import json
-            import re
-            import base64
-            import hashlib
-            
-            def parse(share_link_info, http, logger):
-                url = share_link_info.get_share_url()
-                response = requests.get(url)
-                data = json.loads(response.text)
-                return data.get('download_url', '')
-            """;
-        
-        var result = PyCodeSecurityChecker.check(safeCode);
-        assertTrue("应该通过检查", result.isPassed());
-        log.info("✓ 安全代码正确通过检查");
-    }
-    
-    // ========== 前端模板代码测试 ==========
-    
-    /**
-     * 测试前端模板代码执行（不使用 requests）
-     * 
-     * 注意：由于 GraalPy 的 unicodedata/LLVM 限制，requests 库在后续创建的 Context 中
-     * 无法导入（会抛出 PolyglotException: null）。因此此测试使用不依赖 requests 的模板。
-     * 
-     * requests 功能可以在实际运行时通过首个 Context 使用。
-     */
-    @Test
-    public void testFrontendTemplateCode() throws Exception {
-        log.info("=== 测试13: 前端模板代码执行 ===");
-        
-        // 模拟前端模板代码（不使用 requests，避免 GraalPy 限制）
-        String templateCode = """
-            import re
-            import json
-            import urllib.parse
-            
-            def parse(share_link_info, http, logger):
-                \"\"\"
-                解析单个文件
-                @match https://example\\.com/s/.*
-                @name ExampleParser
-                @version 1.0.0
-                \"\"\"
-                # 获取分享链接
-                share_url = share_link_info.get_share_url()
-                logger.info(f"开始解析: {share_url}")
-                
-                # 提取文件ID
-                match = re.search(r'/s/(\\w+)', share_url)
-                if not match:
-                    raise Exception("无法提取文件ID")
-                
-                file_id = match.group(1)
-                logger.info(f"文件ID: {file_id}")
-                
-                # 模拟解析逻辑（不发起真实请求）
-                if 'example.com' in share_url:
-                    # 返回模拟的下载链接
-                    download_url = f"https://download.example.com/{file_id}/test.zip"
-                    logger.info(f"下载链接: {download_url}")
-                    return download_url
-                else:
-                    raise Exception("不支持的链接")
-            """;
-        
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/test123");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, templateCode);
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        assertTrue("执行应在30秒内完成", latch.await(30, TimeUnit.SECONDS));
-        
-        if (errorRef.get() != null) {
-            log.error("执行失败", errorRef.get());
-            fail("执行失败: " + errorRef.get().getMessage());
-        }
-        
-        // 验证返回结果包含正确的文件ID
-        String result = resultRef.get();
-        assertNotNull("结果不应为空", result);
-        assertTrue("结果应包含文件ID", result.contains("test123"));
-        log.info("✓ 前端模板代码执行成功: {}", result);
-        
-        log.info("  执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("    [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-    
-    // ========== 主方法 - 运行所有测试 ==========
-    
-    public static void main(String[] args) {
-        log.info("======================================");
-        log.info("   Python Playground 完整测试套件");
-        log.info("======================================");
-        
-        org.junit.runner.Result result = org.junit.runner.JUnitCore.runClasses(PyPlaygroundFullTest.class);
-        
-        log.info("\n======================================");
-        log.info("             测试结果");
-        log.info("======================================");
-        log.info("运行测试数: {}", result.getRunCount());
-        log.info("失败测试数: {}", result.getFailureCount());
-        log.info("忽略测试数: {}", result.getIgnoreCount());
-        log.info("运行时间: {} ms", result.getRunTime());
-        
-        if (result.wasSuccessful()) {
-            log.info("\n✅ 所有 {} 个测试通过!", result.getRunCount());
-        } else {
-            log.error("\n❌ {} 个测试失败:", result.getFailureCount());
-            for (org.junit.runner.notification.Failure failure : result.getFailures()) {
-                log.error("  - {}", failure.getTestHeader());
-                log.error("    错误: {}", failure.getMessage());
-            }
-        }
-        
-        System.exit(result.wasSuccessful() ? 0 : 1);
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/PyPlaygroundTestMain.java

@@ -1,288 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-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.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Python 演练场测试主类
- * 直接运行此类来测试 GraalPy 环境
- */
-public class PyPlaygroundTestMain {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyPlaygroundTestMain.class);
-    
-    public static void main(String[] args) throws Exception {
-        log.info("======= Python 演练场测试开始 =======");
-        
-        int passed = 0;
-        int failed = 0;
-        
-        // 测试 1: 基础 Python 执行
-        try {
-            testBasicPythonExecution();
-            passed++;
-            log.info("✓ 测试1: 基础 Python 执行 - 通过");
-        } catch (Exception e) {
-            failed++;
-            log.error("✗ 测试1: 基础 Python 执行 - 失败", e);
-        }
-        
-        // 测试 2: requests 库导入
-        try {
-            testRequestsImport();
-            passed++;
-            log.info("✓ 测试2: requests 库导入 - 通过");
-        } catch (Exception e) {
-            failed++;
-            log.error("✗ 测试2: requests 库导入 - 失败", e);
-        }
-        
-        // 测试 3: 简单 parse 函数
-        try {
-            testSimpleParseFunction();
-            passed++;
-            log.info("✓ 测试3: 简单 parse 函数 - 通过");
-        } catch (Exception e) {
-            failed++;
-            log.error("✗ 测试3: 简单 parse 函数 - 失败", e);
-        }
-        
-        // 测试 4: PyPlaygroundExecutor
-        try {
-            testPyPlaygroundExecutor();
-            passed++;
-            log.info("✓ 测试4: PyPlaygroundExecutor - 通过");
-        } catch (Exception e) {
-            failed++;
-            log.error("✗ 测试4: PyPlaygroundExecutor - 失败", e);
-        }
-        
-        // 测试 5: 安全检查
-        try {
-            testSecurityChecker();
-            passed++;
-            log.info("✓ 测试5: 安全检查 - 通过");
-        } catch (Exception e) {
-            failed++;
-            log.error("✗ 测试5: 安全检查 - 失败", e);
-        }
-        
-        log.info("======= 测试完成 =======");
-        log.info("通过: {}, 失败: {}", passed, failed);
-        
-        if (failed > 0) {
-            System.exit(1);
-        }
-    }
-    
-    /**
-     * 测试基础的 Context 创建和 Python 代码执行
-     */
-    private static void testBasicPythonExecution() {
-        log.info("=== 测试基础 Python 执行 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试简单的 Python 表达式
-            Value result = context.eval("python", "1 + 2");
-            if (result.asInt() != 3) {
-                throw new AssertionError("期望 3, 实际 " + result.asInt());
-            }
-            log.info("  基础表达式: 1 + 2 = {}", result.asInt());
-            
-            // 测试字符串操作
-            Value strResult = context.eval("python", "'hello'.upper()");
-            if (!"HELLO".equals(strResult.asString())) {
-                throw new AssertionError("期望 HELLO, 实际 " + strResult.asString());
-            }
-            log.info("  字符串操作: 'hello'.upper() = {}", strResult.asString());
-        }
-    }
-    
-    /**
-     * 测试 requests 库导入
-     */
-    private static void testRequestsImport() {
-        log.info("=== 测试 requests 库导入 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试 requests 导入
-            context.eval("python", "import requests");
-            log.info("  requests 导入成功");
-            
-            // 验证 requests 版本
-            Value version = context.eval("python", "requests.__version__");
-            log.info("  requests 版本: {}", version.asString());
-            
-            if (version.asString() == null) {
-                throw new AssertionError("requests 版本为空");
-            }
-        }
-    }
-    
-    /**
-     * 测试简单的 parse 函数执行
-     */
-    private static void testSimpleParseFunction() {
-        log.info("=== 测试简单 parse 函数 ===");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                logger.info("测试开始")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            PyPlaygroundLogger logger = new PyPlaygroundLogger();
-            
-            // 注入对象
-            Value bindings = context.getBindings("python");
-            bindings.putMember("logger", logger);
-            
-            // 执行代码定义函数
-            context.eval("python", pyCode);
-            
-            // 获取并调用 parse 函数
-            Value parseFunc = bindings.getMember("parse");
-            if (parseFunc == null || !parseFunc.canExecute()) {
-                throw new AssertionError("parse 函数不存在或不可执行");
-            }
-            
-            // 执行函数
-            Value result = parseFunc.execute(null, null, logger);
-            
-            if (!"https://example.com/download/test.zip".equals(result.asString())) {
-                throw new AssertionError("期望 https://example.com/download/test.zip, 实际 " + result.asString());
-            }
-            log.info("  parse 函数返回: {}", result.asString());
-            
-            // 检查日志
-            if (logger.getLogs().isEmpty()) {
-                throw new AssertionError("没有日志记录");
-            }
-            log.info("  日志记录数: {}", logger.getLogs().size());
-        }
-    }
-    
-    /**
-     * 测试完整的 PyPlaygroundExecutor
-     */
-    private static void testPyPlaygroundExecutor() throws Exception {
-        log.info("=== 测试 PyPlaygroundExecutor ===");
-        
-        String pyCode = """
-            import json
-            
-            def parse(share_link_info, http, logger):
-                url = share_link_info.get_share_url()
-                logger.info(f"解析链接: {url}")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        // 创建 ShareLinkInfo
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        // 创建执行器
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-        
-        // 异步执行
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        // 等待结果
-        if (!latch.await(30, TimeUnit.SECONDS)) {
-            throw new AssertionError("执行超时");
-        }
-        
-        // 检查结果
-        if (errorRef.get() != null) {
-            throw new AssertionError("执行失败: " + errorRef.get().getMessage(), errorRef.get());
-        }
-        
-        if (!"https://example.com/download/test.zip".equals(resultRef.get())) {
-            throw new AssertionError("期望 https://example.com/download/test.zip, 实际 " + resultRef.get());
-        }
-        
-        log.info("  PyPlaygroundExecutor 返回: {}", resultRef.get());
-        log.info("  执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("    [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-    
-    /**
-     * 测试安全检查器拦截危险代码
-     */
-    private static void testSecurityChecker() throws Exception {
-        log.info("=== 测试安全检查器 ===");
-        
-        String dangerousCode = """
-            import subprocess
-            
-            def parse(share_link_info, http, logger):
-                result = subprocess.run(['ls'], capture_output=True)
-                return result.stdout.decode()
-            """;
-        
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, dangerousCode);
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        if (!latch.await(30, TimeUnit.SECONDS)) {
-            throw new AssertionError("执行超时");
-        }
-        
-        // 应该被安全检查器拦截
-        if (errorRef.get() == null) {
-            throw new AssertionError("危险代码应该被拦截，但执行成功了: " + resultRef.get());
-        }
-        
-        String errorMsg = errorRef.get().getMessage();
-        if (!errorMsg.contains("安全检查") && !errorMsg.contains("subprocess")) {
-            throw new AssertionError("错误消息不包含预期内容: " + errorMsg);
-        }
-        
-        log.info("  安全检查器正确拦截: {}", errorMsg);
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/PyTemplateCodeTest.java

@@ -1,139 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * 测试前端模板代码执行
- * 模拟用户使用 Python 模板
- */
-public class PyTemplateCodeTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyTemplateCodeTest.class);
-    
-    // 这是前端发送的模板代码（与 pyParserTemplate.js 中一致）
-    private static final String TEMPLATE_CODE = """
-import requests
-import re
-import json
-
-
-def parse(share_link_info, http, logger):
-    \"\"\"
-    解析单个文件下载链接
-    
-    Args:
-        share_link_info: 分享链接信息对象
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        str: 直链下载地址
-    \"\"\"
-    url = share_link_info.get_share_url()
-    logger.info(f"开始解析: {url}")
-    
-    # 使用 requests 库发起请求（推荐）
-    response = requests.get(url, headers={
-        "Referer": url
-    })
-    
-    if not response.ok:
-        raise Exception(f"请求失败: {response.status_code}")
-    
-    html = response.text
-    
-    # 示例：使用正则表达式提取下载链接
-    # match = re.search(r'download_url["\\\\':]\s*["\\\\']([^"\\\\'>]+)', html)
-    # if match:
-    #     return match.group(1)
-    
-    return "https://example.com/download/file.zip"
-
-
-def parse_file_list(share_link_info, http, logger):
-    \"\"\"
-    解析文件列表（可选）
-    
-    Args:
-        share_link_info: 分享链接信息对象
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        list: 文件信息列表
-    \"\"\"
-    dir_id = share_link_info.get_other_param("dirId") or "0"
-    logger.info(f"解析文件列表，目录ID: {dir_id}")
-    
-    file_list = []
-    
-    return file_list
-""";
-
-    public static void main(String[] args) throws Exception {
-        log.info("======= 测试前端模板代码执行 =======");
-        
-        // 测试代码
-        log.info("测试代码长度: {} 字符", TEMPLATE_CODE.length());
-        log.info("代码前100字符:\n{}", TEMPLATE_CODE.substring(0, Math.min(100, TEMPLATE_CODE.length())));
-        
-        // 创建 ShareLinkInfo - 使用 example.com 测试 URL
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        // 创建执行器
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, TEMPLATE_CODE);
-        
-        // 异步执行
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        log.info("开始执行 Python 代码...");
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        // 等待结果（最多 60 秒）
-        if (!latch.await(60, TimeUnit.SECONDS)) {
-            log.error("执行超时（60秒）");
-            System.exit(1);
-        }
-        
-        // 检查结果
-        if (errorRef.get() != null) {
-            log.error("执行失败: {}", errorRef.get().getMessage());
-            errorRef.get().printStackTrace();
-            
-            // 打印日志
-            log.info("执行日志:");
-            for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-                log.info("  [{}] {}", entry.getLevel(), entry.getMessage());
-            }
-            
-            System.exit(1);
-        }
-        
-        log.info("✓ 执行成功，返回: {}", resultRef.get());
-        
-        // 打印日志
-        log.info("执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("  [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/RequestsFinalTest.java

@@ -1,142 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-
-import static org.junit.Assert.*;
-
-/**
- * 最终 requests 包测试
- * 验证修复后的 PyContextPool 是否能正确加载 requests
- */
-public class RequestsFinalTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(RequestsFinalTest.class);
-    
-    @Test
-    public void testRequestsImportWithPyContextPool() {
-        log.info("==== 最终测试：PyContextPool + requests 导入 ====");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            log.info("Context 创建成功");
-            
-            // 测试 requests 导入
-            context.eval("python", "import requests");
-            log.info("✓ requests 导入成功");
-            
-            // 获取版本信息
-            Value version = context.eval("python", "requests.__version__");
-            String requestsVersion = version.asString();
-            log.info("requests 版本: {}", requestsVersion);
-            
-            assertNotNull("requests 版本应该不为空", requestsVersion);
-            assertFalse("requests 版本应该不为空字符串", requestsVersion.trim().isEmpty());
-            
-            // 测试相关依赖
-            context.eval("python", "import urllib3");
-            context.eval("python", "import certifi");
-            context.eval("python", "import charset_normalizer");
-            context.eval("python", "import idna");
-            log.info("✓ requests 相关依赖导入成功");
-            
-            // 测试基本功能
-            String testScript = """
-                import requests
-                
-                # 测试 Session 创建
-                session = requests.Session()
-                
-                # 测试基本 API 存在
-                api_methods = ['get', 'post', 'put', 'delete', 'head', 'options']
-                available_methods = [method for method in api_methods if hasattr(requests, method)]
-                
-                {
-                    'version': requests.__version__,
-                    'available_methods': available_methods,
-                    'session_created': session is not None,
-                    'test_success': True
-                }
-                """;
-            
-            Value result = context.eval("python", testScript);
-            
-            assertTrue("测试应该成功", result.getMember("test_success").asBoolean());
-            assertTrue("Session应该创建成功", result.getMember("session_created").asBoolean());
-            
-            Value methods = result.getMember("available_methods");
-            assertTrue("应该有可用的HTTP方法", methods.getArraySize() > 0);
-            
-            log.info("✓ requests 基本功能测试通过");
-            log.info("可用方法: {}", methods);
-            
-        } catch (Exception e) {
-            log.error("测试失败", e);
-            fail("requests 导入或功能测试失败: " + e.getMessage());
-        }
-    }
-    
-    @Test
-    public void testCompleteExample() {
-        log.info("==== 测试完整的 Python 脚本示例 ====");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            
-            // 注入测试数据
-            Value bindings = context.getBindings("python");
-            bindings.putMember("test_url", "https://httpbin.org/json");
-            
-            String completeScript = """
-                import requests
-                import json
-                import re
-                import sys
-                import time
-                
-                def test_complete_functionality():
-                    # 模拟一个完整的 Python 脚本
-                    result = {
-                        'imports_success': True,
-                        'requests_version': requests.__version__,
-                        'python_version': sys.version_info[:2],
-                        'timestamp': int(time.time()),
-                        'json_test': json.dumps({'test': 'data'}),
-                        'regex_test': bool(re.search(r'\\d+\\.\\d+', requests.__version__))
-                    }
-                    
-                    # 测试 requests 基本结构
-                    if hasattr(requests, 'get') and hasattr(requests, 'Session'):
-                        result['requests_structure_ok'] = True
-                    else:
-                        result['requests_structure_ok'] = False
-                    
-                    return result
-                
-                # 执行测试
-                test_result = test_complete_functionality()
-                """;
-            
-            context.eval("python", completeScript);
-            Value result = context.eval("python", "test_result");
-            
-            assertTrue("导入应该成功", result.getMember("imports_success").asBoolean());
-            assertTrue("requests 结构应该正确", result.getMember("requests_structure_ok").asBoolean());
-            assertTrue("正则匹配应该成功", result.getMember("regex_test").asBoolean());
-            
-            log.info("✓ 完整脚本测试成功");
-            log.info("Python 版本: {}", result.getMember("python_version"));
-            log.info("requests 版本: {}", result.getMember("requests_version"));
-            
-        } catch (Exception e) {
-            log.error("完整脚本测试失败", e);
-            fail("完整脚本测试失败: " + e.getMessage());
-        }
-    }
-}

parser/src/test/java/cn/qaiu/parser/custompy/SimpleRequestsTest.java

@@ -1,49 +0,0 @@
-package cn.qaiu.parser.custompy;
-
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import static org.junit.Assert.*;
-
-/**
- * 简化的 requests 测试
- */
-public class SimpleRequestsTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(SimpleRequestsTest.class);
-    
-    @Test
-    public void testRequestsImportOnly() {
-        log.info("==== 简单测试：只测试 requests 导入 ====");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            log.info("Context 创建成功");
-            
-            // 只测试 requests 导入
-            context.eval("python", "import requests");
-            log.info("✓ requests 导入成功");
-            
-            // 获取版本
-            Value version = context.eval("python", "requests.__version__");
-            String versionStr = version.asString();
-            log.info("requests 版本: {}", versionStr);
-            
-            assertNotNull("版本不应为空", versionStr);
-            assertTrue("版本不应为空字符串", !versionStr.trim().isEmpty());
-            
-            // 测试基本属性存在
-            Value hasGet = context.eval("python", "hasattr(requests, 'get')");
-            assertTrue("应该有 get 方法", hasGet.asBoolean());
-            
-            log.info("✓ 所有测试通过");
-            
-        } catch (Exception e) {
-            log.error("测试失败", e);
-            fail("测试失败: " + e.getMessage());
-        }
-    }
-}

pom.xml

@@ -22,13 +22,10 @@
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        
-        <!-- 默认跳过测试，可通过 -Dmaven.test.skip=false 来执行测试 -->
-        <maven.test.skip>true</maven.test.skip>
 
         <packageDirectory>${project.basedir}/web-service/target/package</packageDirectory>
 
-        <vertx.version>4.5.23</vertx.version>
+        <vertx.version>4.5.22</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>
@@ -79,13 +76,13 @@
                 </configuration>
             </plugin>
 
-            <!-- 跳过测试类 -->
+            <!-- 跳过测试类-->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>2.22.2</version>
                 <configuration>
-                     <skipTests>${maven.test.skip}</skipTests>
+                     <skipTests>true</skipTests>
                 </configuration>
             </plugin>
             <plugin>

web-front/HOTFIX_2026-01-15.md

@@ -1,165 +0,0 @@
-# 问题修复总结
-
-## 🐛 修复的问题
-
-### 1. Python补全提供器初始化错误 ✅
-**错误**: `ReferenceError: initEPython补全提供器 is not defined`
-
-**原因**: MonacoEditor.vue 中代码格式混乱，注册代码被错误地合并到一行
-
-**修复**:
-```javascript
-// 修复前（错误格式）
-if (editorContainer.value) {
-  // 注册Python补全提供器
-  pythonCompletionProvider = registerPythonCompletionProvider(monaco);
-  console.log('[MonacoEditor] Python补全提供器已注册'); editorContainer.value.style.height = props.height;
-}
-
-// 修复后（正确格式）
-if (editorContainer.value) {
-  editorContainer.value.style.height = props.height;
-}
-
-// 注册Python补全提供器
-pythonCompletionProvider = registerPythonCompletionProvider(monaco);
-console.log('[MonacoEditor] Python补全提供器已注册');
-```
-
-### 2. 编辑器不显示问题 ✅
-**原因**: 代码格式错误导致Monaco编辑器初始化失败
-
-**修复**: 纠正了代码格式，确保编辑器正常初始化
-
-### 3. 悬浮按钮间距问题 ✅
-**问题**: 悬浮按钮之间有8px间距，且不在编辑器内部
-
-**修复**:
-```css
-/* 移除按钮间距，紧密排列 */
-.mobile-editor-actions.large-actions .el-button-group {
-  display: flex;
-  gap: 0;  /* 移除间距 */
-}
-
-.mobile-editor-actions.large-actions .el-button-group .el-button {
-  margin: 0 !important;
-  border-radius: 0 !important;
-}
-
-/* 首尾按钮圆角 */
-.mobile-editor-actions.large-actions .el-button-group .el-button:first-child {
-  border-top-left-radius: 24px !important;
-  border-bottom-left-radius: 24px !important;
-}
-
-.mobile-editor-actions.large-actions .el-button-group .el-button:last-child {
-  border-top-right-radius: 24px !important;
-  border-bottom-right-radius: 24px !important;
-}
-```
-
-**效果**:
-- ✅ 按钮无间距，紧密连接
-- ✅ 首尾按钮圆角，美观
-- ✅ 位于编辑器区域内部（`position: relative`）
-
-## 📦 部署信息
-
-**构建时间**: 2026-01-15 09:57:18  
-**构建文件**: app.845c8834.js (167KB)  
-**构建状态**: ✅ 成功  
-**部署状态**: ✅ 已部署到 webroot/nfd-front/
-
-## 🎨 UI 改进
-
-### 悬浮按钮组
-```
-┌─────────────────────────────────────┐
-│                                     │
-│                                     │
-│           Monaco 编辑器              │
-│                                     │
-│                                     │
-│              ┌──────────────┐       │
-│              │🔄🔃✨□▶│ 48px │
-│              └──────────────┘       │
-└─────────────────────────────────────┘
-         无间距，紧密连接
-```
-
-**按钮说明**:
-- 🔄 撤销 (Undo)
-- 🔃 重做 (Redo)  
-- ✨ 格式化 (Format)
-- □ 全选 (Select All)
-- ▶ 运行测试 (Run) - 蓝色主色调
-
-## ✅ 验证清单
-
-- [x] Python补全正常工作
-- [x] 编辑器正常显示
-- [x] 悬浮按钮无间距
-- [x] 悬浮按钮在编辑器内
-- [x] 按钮圆角美观
-- [x] 构建无错误
-- [x] 部署成功
-
-## 🔍 测试步骤
-
-1. **测试编辑器显示**:
-   - 打开演练场页面
-   - 确认Monaco编辑器正常显示
-   - 确认代码高亮正常
-
-2. **测试Python补全**:
-   - 新建Python文件
-   - 输入 `if` - 应显示补全提示
-   - 输入 `for` - 应显示循环模板
-   - 输入 `def` - 应显示函数定义模板
-
-3. **测试悬浮按钮**:
-   - 移动端查看
-   - 确认5个按钮紧密连接
-   - 确认按钮位于编辑器右下角
-   - 确认首尾按钮圆角
-   - 点击运行按钮测试功能
-
-## 📱 移动端最终效果
-
-```
-┌────────────────────────────────────┐
-│  🏠 首页 > 演练场 (Python) LSP ✓   │
-├────────────────────────────────────┤
-│ ┌─────┬─────┬─────┬─────┬─────┐   │
-│ │运行 │保存 │格式化│新建 │...  │   │ 顶部操作栏
-│ └─────┴─────┴─────┴─────┴─────┘   │
-├────────────────────────────────────┤
-│ [示例解析器.py *]  [+]              │ 文件标签
-├────────────────────────────────────┤
-│                                    │
-│  1 def parse(share_info):          │
-│  2     """解析函数"""               │
-│  3     if<-- 补全提示               │ Monaco编辑器
-│  4                                  │
-│  5                                  │
-│ ...                                 │
-│                                    │
-│              ┌──────────────┐      │
-│              │🔄🔃✨□▶│      │ 悬浮按钮
-│              └──────────────┘      │
-└────────────────────────────────────┘
-```
-
-## 🚀 后续优化建议
-
-1. 添加按钮长按提示
-2. 优化按钮触控反馈
-3. 支持按钮自定义顺序
-4. 添加更多快捷操作
-
----
-
-**修复完成时间**: 2026-01-15 09:57  
-**影响范围**: 编辑器初始化、悬浮按钮UI  
-**风险等级**: 低（仅UI和初始化逻辑）

web-front/PLAYGROUND_REFACTOR_COMPLETE.md

@@ -1,184 +0,0 @@
-# Playground 重构完成总结
-
-## 🎉 已完成的功能
-
-### 1. Python 代码补全 ✅
-- **位置**: `src/utils/pythonCompletions.js`
-- **功能**:
-  - 32个Python关键字补全（if, for, while, def, class等）
-  - 55个内置函数补全（print, len, range等）
-  - 30+个代码片段模板（if-else, for循环, 函数定义等）
-- **使用方式**: 在Monaco编辑器中输入代码时自动触发
-- **优势**: 提高Python开发效率，减少语法错误
-
-### 2. PC端Tab界面优化 ✅
-- **位置**: `src/components/TestPanel.vue`
-- **功能**:
-  - 测试参数和代码问题整合为Tab页签
-  - 测试Tab：分享链接（支持URL历史）、密码、方法选择、执行结果
-  - 问题Tab：显示代码问题列表，点击跳转到对应行
-- **优势**: 更清晰的信息组织，减少视觉混乱
-
-### 3. 移动端模态框 ✅
-- **位置**: `src/components/MobileTestModal.vue`
-- **功能**:
-  - 全屏模态框展示测试参数
-  - URL历史记录自动完成
-  - 执行结果单独弹窗查看详情
-- **优势**: 避免移动端滚动混乱，更好的触控体验
-
-### 4. URL历史记录 ✅
-- **存储**: LocalStorage (key: `playground_url_history`)
-- **容量**: 最多10条
-- **功能**:
-  - 自动保存成功执行的测试URL
-  - 下拉选择历史URL
-  - 支持搜索过滤
-- **优势**: 快速重复测试，无需复制粘贴
-
-### 5. 悬浮按钮优化 ✅
-- **尺寸**: 从默认尺寸增大到48x48px
-- **按钮**: 撤销、重做、格式化、全选、**运行测试**（新增）
-- **位置**: 右下角，不遮挡编辑器内容
-- **优势**: 移动端更容易点击，功能更集中
-
-### 6. 编辑器高度优化 ✅
-- **移动端**: `calc(100vh - 220px)`
-- **最小高度**: 500px
-- **自适应**: 根据屏幕尺寸动态调整
-- **优势**: 最大化编辑空间，减少滚动
-
-## 📦 新增文件
-
-```
-web-front/src/
-├── utils/
-│   └── pythonCompletions.js      # Python补全提供器
-└── components/
-    ├── TestPanel.vue              # PC端测试面板Tab组件
-    └── MobileTestModal.vue        # 移动端测试模态框组件
-```
-
-## 🔧 修改的文件
-
-1. **MonacoEditor.vue**
-   - 集成Python补全提供器
-   - 在组件初始化时注册
-   - 在组件销毁时清理
-
-2. **Playground.vue** (核心重构)
-   - 添加组件导入
-   - 替换PC端测试面板为TestPanel组件
-   - 集成MobileTestModal组件
-   - 添加URL历史记录功能
-   - 优化悬浮按钮尺寸和功能
-   - 添加CSS样式优化
-
-## 📊 代码统计
-
-| 项目 | 修改前 | 修改后 | 变化 |
-|------|--------|--------|------|
-| Playground.vue 行数 | 5441 | 5369 | -72 (-1.3%) |
-| 新增文件 | 0 | 3 | +3 |
-| 总代码行数 | ~5500 | ~5900 | +400 (+7.3%) |
-
-## 🎯 用户体验提升
-
-### PC端
-- ✅ Tab页签切换更直观
-- ✅ URL自动完成提高效率
-- ✅ 代码问题集中展示
-- ✅ Python补全提高开发效率
-
-### 移动端
-- ✅ 全屏模态框避免滚动混乱
-- ✅ 48px大按钮更容易点击
-- ✅ 运行按钮集成到操作组
-- ✅ 编辑器高度优化，减少滚动
-
-## 🧪 测试结果
-
-### 构建测试
-```bash
-npm run build
-✅ 构建成功（有警告但无错误）
-⚠️  Warning: Asset size limit (244 KiB)
-```
-
-### 功能测试清单
-- [x] PC端Tab切换正常
-- [x] 移动端模态框正常打开/关闭
-- [x] Python补全正常工作
-- [x] URL历史记录保存和加载
-- [x] 悬浮按钮尺寸正确（48px）
-- [x] 编辑器高度填充屏幕
-- [x] 组件正确导入和渲染
-
-## 📝 使用指南
-
-### Python补全使用
-1. 新建或打开Python文件（.py）
-2. 输入关键字前几个字母
-3. 自动弹出补全建议
-4. 按Tab或Enter选择
-5. 支持的补全：
-   - `if` → if条件语句
-   - `for` → for循环
-   - `def` → 函数定义
-   - `class` → 类定义
-   - 等等...
-
-### URL历史记录使用
-1. PC端：在分享链接输入框中点击，自动显示历史
-2. 移动端：点击运行按钮 → 模态框 → URL输入框下拉
-3. 选择历史URL自动填充
-4. 成功执行测试后自动保存到历史
-
-### 移动端模态框使用
-1. 点击右下角"运行"按钮（蓝色三角形）
-2. 弹出全屏测试模态框
-3. 填写参数并执行
-4. 点击"查看详情"查看完整结果
-5. 关闭模态框返回编辑器
-
-## 🚀 性能优化
-
-1. **代码拆分**: 将5441行巨型组件拆分，提高可维护性
-2. **懒加载**: 组件按需加载，减少初始包大小
-3. **LocalStorage**: 历史记录本地存储，减少服务器请求
-4. **CSS优化**: 使用CSS变量和calc()，减少硬编码
-
-## 🐛 已知问题
-
-1. ⚠️  Asset size警告（Monaco Editor占用较大）
-   - 影响: 首次加载时间
-   - 解决方案: 已配置gzip压缩，实际影响较小
-
-## 📚 相关文档
-
-- [重构计划](./PLAYGROUND_REFACTOR_PLAN.md)
-- [实施方案](./PLAYGROUND_REFACTOR_IMPLEMENTATION.md)
-- [Python补全API](../src/utils/pythonCompletions.js)
-
-## 🙏 贡献者
-
-- GitHub Copilot - 代码生成和重构建议
-- 项目维护者 - 需求分析和测试验证
-
-## 📅 版本信息
-
-- 重构日期: 2026-01-15
-- 版本: v2.0
-- 分支: feature/playground-refactor
-- 构建: 成功 ✅
-
----
-
-## 下一步计划
-
-1. [ ] 监控用户反馈
-2. [ ] 优化Monaco Editor加载性能
-3. [ ] 添加更多Python代码片段
-4. [ ] 支持JavaScript代码片段补全
-5. [ ] 添加URL历史搜索功能
-6. [ ] 移动端手势操作优化

web-front/PLAYGROUND_REFACTOR_IMPLEMENTATION.md

@@ -1,280 +0,0 @@
-# Playground.vue 重构实施方案
-
-## 已完成的工作
-1. ✅ 创建 Python 补全模块 (`src/utils/pythonCompletions.js`)
-2. ✅ 创建 TestPanel 组件 (`src/components/TestPanel.vue`)
-3. ✅ 创建 MobileTestModal 组件 (`src/components/MobileTestModal.vue`)
-4. ✅ 更新 MonacoEditor 集成 Python 补全
-
-## 需要在Playground.vue中实施的改动
-
-### 1. 导入新组件（在script setup顶部）
-
-```javascript
-import TestPanel from '@/components/TestPanel.vue';
-import MobileTestModal from '@/components/MobileTestModal.vue';
-```
-
-### 2. PC端：替换右侧面板为TestPanel组件
-
-**位置**：行638-656（桌面端 Pane 区域）
-
-**原代码**：
-```vue
-<Pane v-if="!collapsedPanels.rightPanel" 
-  :size="splitSizes[1]" min-size="20" class="test-pane" style="margin-left: 10px;">
-  <div class="test-section">
-    <!-- 3个卡片：测试参数、代码问题、执行结果 -->
-  </div>
-</Pane>
-```
-
-**新代码**：
-```vue
-<Pane v-if="!collapsedPanels.rightPanel" 
-  :size="splitSizes[1]" min-size="20" class="test-pane" style="margin-left: 10px;">
-  <div class="test-section">
-    <!-- 折叠按钮 -->
-    <el-tooltip content="折叠测试面板" placement="left">
-      <div class="panel-collapse-btn" @click="toggleRightPanel">
-        <el-icon><CaretRight /></el-icon>
-      </div>
-    </el-tooltip>
-    
-    <!-- 使用TestPanel组件 -->
-    <TestPanel
-      :test-params="testParams"
-      :test-result="testResult"
-      :testing="testing"
-      :code-problems="codeProblems"
-      :url-history="urlHistory"
-      @execute-test="executeTest"
-      @clear-result="testResult = null"
-      @goto-problem="goToProblemLine"
-      @update:test-params="(params) => Object.assign(testParams, params)"
-    />
-  </div>
-</Pane>
-```
-
-### 3. 移动端：替换测试区域为浮动按钮 + MobileTestModal
-
-**位置**：行280-455（移动端布局区域）
-
-**改动**：
-1. 移除现有的测试参数表单（行330-410）
-2. 添加悬浮运行按钮到编辑器操作按钮组
-3. 在模板底部添加 MobileTestModal 组件
-
-**新的悬浮按钮代码**：
-```vue
-<!-- 移动端悬浮操作按钮 - 增大尺寸 -->
-<div class="mobile-editor-actions large-actions">
-  <el-button-group size="large">
-    <el-tooltip content="撤销 (Ctrl+Z)" placement="top">
-      <el-button icon="RefreshLeft" circle @click="undo" class="action-btn-large" />
-    </el-tooltip>
-    <el-tooltip content="重做 (Ctrl+Y)" placement="top">
-      <el-button icon="RefreshRight" circle @click="redo" class="action-btn-large" />
-    </el-tooltip>
-    <el-tooltip content="格式化 (Shift+Alt+F)" placement="top">
-      <el-button icon="MagicStick" circle @click="formatCode" class="action-btn-large" />
-    </el-tooltip>
-    <el-tooltip content="全选 (Ctrl+A)" placement="top">
-      <el-button icon="Select" circle @click="selectAll" class="action-btn-large" />
-    </el-tooltip>
-    <el-tooltip content="运行测试" placement="top">
-      <el-button 
-        type="primary" 
-        icon="CaretRight" 
-        circle 
-        @click="mobileTestDialogVisible = true" 
-        class="action-btn-large"
-      />
-    </el-tooltip>
-  </el-button-group>
-</div>
-```
-
-**在模板底部添加（行1150前）**：
-```vue
-<!-- 移动端测试模态框 -->
-<MobileTestModal
-  v-model="mobileTestDialogVisible"
-  :test-params="testParams"
-  :test-result="testResult"
-  :testing="testing"
-  :url-history="urlHistory"
-  @execute-test="handleMobileExecuteTest"
-  @update:test-params="(params) => Object.assign(testParams, params)"
-/>
-```
-
-### 4. URL历史记录功能
-
-**在script setup中添加（约行2200附近）**：
-
-```javascript
-// 从localStorage加载URL历史
-onMounted(() => {
-  const saved = localStorage.getItem(HISTORY_KEY);
-  if (saved) {
-    try {
-      urlHistory.value = JSON.parse(saved);
-    } catch (e) {
-      console.error('加载URL历史失败:', e);
-      urlHistory.value = [];
-    }
-  }
-});
-
-// 添加URL到历史记录
-const addToUrlHistory = (url) => {
-  if (!url || !url.trim()) return;
-  
-  // 去重并添加到开头
-  const filtered = urlHistory.value.filter(item => item !== url);
-  filtered.unshift(url);
-  
-  // 限制数量
-  if (filtered.length > MAX_HISTORY) {
-    filtered.length = MAX_HISTORY;
-  }
-  
-  urlHistory.value = filtered;
-  localStorage.setItem(HISTORY_KEY, JSON.stringify(filtered));
-};
-
-// 修改executeTest函数，在成功执行后添加到历史
-// 找到executeTest函数（约行2400），在测试成功后添加：
-const executeTest = async () => {
-  // ... 现有代码 ...
-  
-  // 测试成功后
-  if (testResult.value && testResult.value.success) {
-    addToUrlHistory(testParams.value.shareUrl);
-  }
-};
-
-// 移动端执行测试
-const handleMobileExecuteTest = async () => {
-  await executeTest();
-  // 如果执行成功，显示结果提示
-  if (testResult.value && testResult.value.success) {
-    ElMessage.success('测试执行成功，点击"查看详情"查看结果');
-  }
-};
-```
-
-### 5. 编辑器高度优化
-
-**在style部分添加（约行4800）**：
-
-```css
-/* 移动端编辑器高度优化 */
-@media screen and (max-width: 768px) {
-  .mobile-layout .editor-section {
-    min-height: calc(100vh - 220px); /* 顶部导航60px + 按钮区域120px + 间距40px */
-  }
-  
-  .mobile-layout .editor-section :deep(.monaco-editor-container) {
-    min-height: 500px;
-  }
-}
-
-/* 悬浮按钮 - 增大尺寸 */
-.mobile-editor-actions.large-actions {
-  right: 12px;
-  bottom: 12px;
-}
-
-.mobile-editor-actions.large-actions .action-btn-large {
-  width: 48px !important;
-  height: 48px !important;
-  font-size: 20px !important;
-}
-
-.mobile-editor-actions.large-actions .el-button + .el-button {
-  margin-left: 8px;
-}
-```
-
-### 6. return语句中添加新的响应式引用
-
-**在return对象中添加（约行3100）**：
-
-```javascript
-return {
-  // ... 现有属性 ...
-  
-  // 新增
-  urlHistory,
-  mobileTestDialogVisible,
-  handleMobileExecuteTest,
-  addToUrlHistory,
-  
-  // ... 其余属性 ...
-};
-```
-
-## 关键改进总结
-
-### 功能增强
-1. **Python补全**：关键字、内置函数、代码片段自动补全
-2. **PC端Tab界面**：测试和问题整合为Tab页签
-3. **移动端模态框**：测试参数移到全屏模态框
-4. **URL历史记录**：自动保存最近10条URL，支持自动完成
-5. **悬浮按钮优化**：增大尺寸到48px，添加运行按钮
-
-### 代码优化
-1. **组件拆分**：5441行减少约500行，提升可维护性
-2. **逻辑解耦**：测试面板独立组件，便于复用
-3. **用户体验**：
-   - PC：Tab切换更直观
-   - 移动：模态框避免滚动混乱
-   - 历史记录：快速重复测试
-
-## 实施顺序
-
-1. ✅ 创建工具模块和组件（已完成）
-2. ⏳ 更新Playground.vue导入
-3. ⏳ PC端集成TestPanel
-4. ⏳ 移动端集成MobileTestModal
-5. ⏳ 添加URL历史记录功能
-6. ⏳ 优化CSS样式
-7. ⏳ 测试所有功能
-8. ⏳ 构建和部署
-9. ⏳ 更新文档
-
-## 测试检查清单
-
-- [ ] PC端Tab切换正常
-- [ ] 移动端模态框正常打开/关闭
-- [ ] Python补全正常工作（if, for, def等）
-- [ ] URL历史记录保存和加载
-- [ ] 悬浮按钮尺寸正确（48px）
-- [ ] 编辑器高度填充屏幕
-- [ ] 测试执行功能正常
-- [ ] 代码问题显示正常
-- [ ] 主题切换不影响新组件
-- [ ] 移动/PC响应式切换正常
-
-## 回滚方案
-
-如果出现问题，可通过以下步骤回滚：
-
-```bash
-# 1. 恢复Playground.vue
-git checkout HEAD -- src/views/Playground.vue
-
-# 2. 删除新文件
-rm src/utils/pythonCompletions.js
-rm src/components/TestPanel.vue
-rm src/components/MobileTestModal.vue
-
-# 3. 恢复MonacoEditor.vue
-git checkout HEAD -- src/components/MonacoEditor.vue
-
-# 4. 重新构建
-npm run build
-```

web-front/PLAYGROUND_REFACTOR_PLAN.md

@@ -1,206 +0,0 @@
-# Playground 移动端优化重构方案
-
-## 当前问题
-1. 移动端代码问题布局显示异常
-2. PC端测试区域和问题区域混杂
-3. 移动端编辑器高度不够
-4. 缺少URL历史记录功能
-5. 悬浮按钮组功能单一
-
-## 改进方案
-
-### 1. PC端 - Tab页签模式
-- 右侧面板改为Tab页签
-  - 测试 (Debug图标)
-  - 问题 (感叹号图标)
-- 统一的折叠/展开按钮
-
-### 2. 移动端 - 模态框模式
-- 移除底部固定的测试参数区域
-- 添加两个悬浮模态框触发按钮：
-  - 运行测试 (三角形图标)
-  - 查看问题 (感叹号图标)
-- 测试模态框包含：
-  - URL输入（带历史记录下拉）
-  - 密码输入
-  - 方法选择
-  - 执行按钮
-  - 结果展示
-  
-### 3. URL历史记录
-- LocalStorage存储最近10条
-- 下拉选择历史URL
-- 点击快速填充
-
-### 4. 悬浮按钮组优化
-- 增大按钮尺寸
-- 添加运行按钮
-- 位置：右下角
-- 按钮：撤销、重做、格式化、全选、运行
-
-### 5. 编辑器高度优化
-- 移动端：calc(100vh - 顶部导航 - 按钮区域 - 10px)
-- PC端：保持当前分屏模式
-
-## 实现步骤
-
-### 步骤1：添加状态变量
-```javascript
-//  URL历史记录
-const urlHistory = ref([]);
-const HISTORY_KEY = 'playground_url_history';
-
-// 模态框状态
-const mobileTestDialogVisible = ref(false);
-const mobileResultDialogVisible = ref(false);
-
-// Tab页签
-const rightPanelTab = ref('test'); // 'test' | 'problems'
-```
-
-### 步骤2：URL历史记录功能
-```javascript
-// 加载历史
-onMounted(() => {
-  const history = localStorage.getItem(HISTORY_KEY);
-  if (history) {
-    urlHistory.value = JSON.parse(history);
-  }
-});
-
-// 添加到历史
-const addToHistory = (url) => {
-  if (!url || !url.trim()) return;
-  
-  // 去重
-  const filtered = urlHistory.value.filter(item => item !== url);
-  filtered.unshift(url);
-  
-  // 限制数量
-  if (filtered.length > MAX_HISTORY) {
-    filtered.length = MAX_HISTORY;
-  }
-  
-  urlHistory.value = filtered;
-  localStorage.setItem(HISTORY_KEY, JSON.stringify(filtered));
-};
-```
-
-### 步骤3：PC端Tab页签
-替换当前右侧面板的3个独立卡片为：
-```vue
-<el-tabs v-model="rightPanelTab" class="right-panel-tabs">
-  <el-tab-pane name="test">
-    <template #label>
-      <span class="tab-label">
-        <el-icon><Stopwatch /></el-icon>
-        测试
-      </span>
-    </template>
-    <!-- 测试参数 + 结果 -->
-  </el-tab-pane>
-  
-  <el-tab-pane name="problems">
-    <template #label>
-      <span class="tab-label">
-        <el-icon><WarningFilled /></el-icon>
-        问题
-        <el-badge v-if="codeProblems.length > 0" :value="codeProblems.length" />
-      </span>
-    </template>
-    <!-- 代码问题列表 -->
-  </el-tab-pane>
-</el-tabs>
-```
-
-### 步骤4：移动端模态框
-```vue
-<!-- 测试模态框 -->
-<el-dialog
-  v-model="mobileTestDialogVisible"
-  title="运行测试"
-  :fullscreen="true"
-  class="mobile-test-dialog"
->
-  <!-- URL输入带历史记录 -->
-  <el-select
-    v-model="testParams.shareUrl"
-    filterable
-    allow-create
-    placeholder="输入或选择URL"
-  >
-    <el-option
-      v-for="url in urlHistory"
-      :key="url"
-      :label="url"
-      :value="url"
-    />
-  </el-select>
-  
-  <!-- 其他表单项 -->
-  <!-- 执行按钮 -->
-  <!-- 结果显示 -->
-</el-dialog>
-```
-
-### 步骤5：优化悬浮按钮
-```vue
-<div class="mobile-editor-actions large">
-  <el-button-group size="large">
-    <el-button icon="RefreshLeft" circle @click="undo" />
-    <el-button icon="RefreshRight" circle @click="redo" />
-    <el-button icon="MagicStick" circle @click="formatCode" />
-    <el-button icon="Select" circle @click="selectAll" />
-    <el-button 
-      type="primary" 
-      icon="CaretRight" 
-      circle 
-      @click="mobileTestDialogVisible = true" 
-    />
-  </el-button-group>
-</div>
-```
-
-CSS:
-```css
-.mobile-editor-actions.large .el-button {
-  width: 48px !important;
-  height: 48px !important;
-  font-size: 20px !important;
-}
-```
-
-### 步骤6：编辑器高度
-```css
-/* 移动端编辑器高度 */
-@media screen and (max-width: 768px) {
-  .mobile-layout .editor-section {
-    height: calc(100vh - 120px) !important;
-  }
-  
-  .mobile-layout .editor-section :deep(.monaco-editor-container) {
-    height: 100% !important;
-  }
-}
-```
-
-## 文件修改清单
-
-### 需要修改的部分：
-1. `<script setup>` 部分：添加新的状态变量和函数
-2. `<template>` 部分：
-   - PC端：替换右侧面板为Tab
-   - 移动端：添加模态框，移除底部测试区
-   - 优化悬浮按钮组
-3. `<style>` 部分：
-   - 添加Tab样式
-   - 添加模态框样式  
-   - 调整编辑器高度
-   - 优化悬浮按钮尺寸
-
-## 注意事项
-1. 保持向后兼容
-2. 测试各种屏幕尺寸
-3. 确保URL历史记录不会泄露敏感信息
-4. 模态框要支持键盘操作（ESC关闭）
-5. 优化动画过渡效果

web-front/package.json

@@ -19,7 +19,6 @@
     "element-plus": "2.11.3",
     "monaco-editor": "^0.55.1",
     "qrcode": "^1.5.4",
-    "sockjs-client": "^1.6.1",
     "splitpanes": "^4.0.4",
     "vue": "^3.5.12",
     "vue-clipboard3": "^2.0.0",

web-front/src/components/MobileTestModal.vue

@@ -1,326 +0,0 @@
-<!-- 移动端测试弹框组件 - 非全屏，动态高度 -->
-<template>
-  <el-dialog
-    v-model="visible"
-    :fullscreen="false"
-    :show-close="false"
-    :close-on-click-modal="true"
-    :close-on-press-escape="true"
-    class="mobile-test-modal"
-    width="90%"
-    top="auto"
-    align-center
-  >
-    <div class="modal-content">
-      <!-- 测试参数表单 -->
-      <el-form :model="localParams" size="default" class="test-form" label-position="top">
-        <el-form-item label="分享链接">
-          <el-autocomplete
-            v-model="localParams.shareUrl"
-            :fetch-suggestions="queryUrlHistory"
-            placeholder="https://example.com/s/abc"
-            clearable
-            style="width: 100%;"
-            @select="handleUrlSelect"
-          >
-            <template #prefix>
-              <el-icon><Link /></el-icon>
-            </template>
-          </el-autocomplete>
-        </el-form-item>
-        
-        <el-form-item label="密码（可选）">
-          <el-input
-            v-model="localParams.pwd"
-            placeholder="请输入密码"
-            clearable
-            size="default"
-          >
-            <template #prefix>
-              <el-icon><Lock /></el-icon>
-            </template>
-          </el-input>
-        </el-form-item>
-        
-        <el-form-item label="方法">
-          <el-radio-group v-model="localParams.method">
-            <el-radio label="parse">parse</el-radio>
-            <el-radio label="parseFileList">parseFileList</el-radio>
-          </el-radio-group>
-        </el-form-item>
-      </el-form>
-      
-      <!-- 执行按钮 -->
-      <el-button
-        type="primary"
-        :loading="testing"
-        @click="handleExecute"
-        style="width: 100%;"
-      >
-        <el-icon v-if="!testing"><CaretRight /></el-icon>
-        <span>{{ testing ? '执行中...' : '执行测试' }}</span>
-      </el-button>
-      
-      <!-- 执行结果 - 直接显示 -->
-      <transition name="slide-up">
-        <div v-if="testResult" class="result-section">
-          <el-divider />
-          
-          <el-alert
-            :type="testResult.success ? 'success' : 'error'"
-            :title="testResult.success ? '✓ 执行成功' : '✗ 执行失败'"
-            :closable="false"
-            style="margin-bottom: 12px;"
-          />
-          
-          <!-- 成功结果 -->
-          <div v-if="testResult.success && testResult.result" class="result-data">
-            <div class="section-title">结果数据：</div>
-            <el-input
-              type="textarea"
-              :model-value="testResult.result"
-              readonly
-              :autosize="{ minRows: 2, maxRows: 8 }"
-              class="result-textarea"
-            />
-          </div>
-          <div v-else-if="testResult.success && !testResult.result" class="result-data">
-            <div class="empty-data">（无数据）</div>
-          </div>
-
-          <!-- 错误信息 -->
-          <div v-if="testResult.error" class="result-error">
-            <div class="section-title">错误信息：</div>
-            <el-alert type="error" :title="testResult.error" :closable="false" />
-            <div v-if="testResult.stackTrace" class="stack-trace">
-              <el-collapse>
-                <el-collapse-item title="查看堆栈信息" name="stack">
-                  <pre>{{ testResult.stackTrace }}</pre>
-                </el-collapse-item>
-              </el-collapse>
-            </div>
-          </div>
-
-          <!-- 执行时间 -->
-          <div v-if="testResult.executionTime" class="execution-time">
-            ⏱ 执行时间：{{ testResult.executionTime }}ms
-          </div>
-        </div>
-      </transition>
-    </div>
-  </el-dialog>
-</template>
-
-<script setup>
-import { ref, watch } from 'vue';
-import { Link, Lock, Close, CaretRight } from '@element-plus/icons-vue';
-import JsonViewer from 'vue3-json-viewer';
-import 'vue3-json-viewer/dist/index.css';
-
-const props = defineProps({
-  modelValue: {
-    type: Boolean,
-    default: false
-  },
-  testParams: {
-    type: Object,
-    required: true
-  },
-  testResult: {
-    type: Object,
-    default: null
-  },
-  testing: {
-    type: Boolean,
-    default: false
-  },
-  urlHistory: {
-    type: Array,
-    default: () => []
-  }
-});
-
-const emit = defineEmits(['update:modelValue', 'execute-test', 'update:testParams']);
-
-const visible = ref(props.modelValue);
-const localParams = ref({ ...props.testParams });
-
-watch(() => props.modelValue, (val) => {
-  visible.value = val;
-  if (val) {
-    localParams.value = { ...props.testParams };
-  }
-});
-
-watch(visible, (val) => {
-  emit('update:modelValue', val);
-});
-
-watch(() => props.testParams, (val) => {
-  localParams.value = { ...val };
-}, { deep: true });
-
-// URL历史记录查询
-const queryUrlHistory = (queryString, cb) => {
-  const results = queryString 
-    ? props.urlHistory
-        .filter(url => url.toLowerCase().includes(queryString.toLowerCase()))
-        .map(url => ({ value: url }))
-    : props.urlHistory.map(url => ({ value: url }));
-  cb(results);
-};
-
-// 选择历史URL
-const handleUrlSelect = (item) => {
-  localParams.value.shareUrl = item.value;
-};
-
-// 执行测试
-const handleExecute = () => {
-  emit('update:testParams', localParams.value);
-  emit('execute-test');
-};
-
-// 关闭对话框
-const handleClose = () => {
-  visible.value = false;
-};
-</script>
-
-<style scoped>
-.mobile-test-modal :deep(.el-dialog) {
-  margin: 0 !important;
-  max-height: 75vh;
-  display: flex;
-  flex-direction: column;
-  border-radius: 12px;
-}
-
-.mobile-test-modal :deep(.el-dialog__header) {
-  padding: 0;
-  margin: 0;
-  flex-shrink: 0;
-}
-
-.mobile-test-modal :deep(.el-dialog__body) {
-  padding: 16px;
-  overflow-y: auto;
-  flex: 1;
-  max-height: calc(75vh - 50px);
-}
-
-.modal-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 12px 16px;
-  border-bottom: 1px solid var(--el-border-color);
-  font-size: 16px;
-  font-weight: 600;
-  background: var(--el-bg-color);
-  border-radius: 12px 12px 0 0;
-}
-
-.close-btn {
-  font-size: 20px;
-  cursor: pointer;
-  color: var(--el-text-color-secondary);
-  transition: color 0.2s;
-}
-
-.close-btn:hover {
-  color: var(--el-text-color-primary);
-}
-
-.modal-content {
-  padding-top: 5px;
-}
-
-.test-form {
-  margin-bottom: 10px;
-}
-
-.test-form :deep(.el-form-item) {
-  margin-bottom: 14px;
-}
-
-.test-form :deep(.el-form-item__label) {
-  font-size: 13px;
-  padding-bottom: 4px;
-}
-
-.result-section {
-  margin-top: 10px;
-}
-
-.section-title {
-  font-weight: 600;
-  margin-bottom: 8px;
-  color: var(--el-text-color-primary);
-  font-size: 13px;
-}
-
-.result-data {
-  margin-bottom: 12px;
-}
-
-.json-viewer-wrapper {
-  max-height: 200px;
-  overflow-y: auto;
-  border: 1px solid var(--el-border-color-lighter);
-  border-radius: 6px;
-  padding: 8px;
-  background: var(--el-fill-color-blank);
-}
-
-.json-viewer-wrapper :deep(.jv-container) {
-  font-size: 12px;
-}
-
-.result-error {
-  margin-bottom: 12px;
-}
-
-.stack-trace {
-  margin-top: 10px;
-}
-
-.stack-trace pre {
-  background: var(--el-fill-color-light);
-  padding: 10px;
-  border-radius: 4px;
-  font-size: 11px;
-  overflow-x: auto;
-  max-height: 150px;
-  line-height: 1.4;
-}
-
-.execution-time {
-  padding: 8px 10px;
-  background: var(--el-fill-color-light);
-  border-radius: 4px;
-  font-size: 12px;
-  color: var(--el-text-color-secondary);
-}
-
-.empty-data {
-  color: var(--el-text-color-secondary);
-  font-style: italic;
-  padding: 10px;
-  background: var(--el-fill-color-light);
-  border-radius: 6px;
-  text-align: center;
-  font-size: 13px;
-}
-
-.slide-up-enter-active,
-.slide-up-leave-active {
-  transition: all 0.3s ease;
-}
-
-.slide-up-enter-from,
-.slide-up-leave-to {
-  opacity: 0;
-  transform: translateY(10px);
-}
-</style>

web-front/src/components/MonacoEditor.vue

@@ -4,7 +4,6 @@
 
 <script>
 import { ref, onMounted, onBeforeUnmount, watch } from 'vue';
-import { registerPythonCompletionProvider, disposePythonCompletionProvider } from '@/utils/pythonCompletions';
 
 export default {
   name: 'MonacoEditor',
@@ -36,7 +35,6 @@ export default {
     let editor = null;
     let monaco = null;
     let touchHandlers = { start: null, move: null };
-    let pythonCompletionProvider = null;
 
     const defaultOptions = {
       value: props.modelValue,
@@ -127,35 +125,6 @@ export default {
           ...defaultOptions,
           value: props.modelValue
         });
-        
-        // 为JavaScript添加全局对象的类型定义，避免"已声明但未使用"的警告
-        if (monaco.languages && monaco.languages.typescript) {
-          const jsDefaults = monaco.languages.typescript.javascriptDefaults;
-          
-          // 添加全局对象的类型定义
-          jsDefaults.addExtraLib(`
-            // 演练场运行时注入的全局对象
-            declare const shareLinkInfo: {
-              getShareUrl(): string;
-              getShareKey(): string;
-              getOtherParam(key: string): string;
-              getFullShareUrl(): string;
-            };
-            
-            declare const http: {
-              get(url: string, headers?: Record<string, string>): any;
-              post(url: string, body: any, headers?: Record<string, string>): any;
-              sendJson(url: string, json: any, headers?: Record<string, string>): any;
-            };
-            
-            declare const logger: {
-              info(message: string, ...args: any[]): void;
-              debug(message: string, ...args: any[]): void;
-              warn(message: string, ...args: any[]): void;
-              error(message: string, ...args: any[]): void;
-            };
-          `, 'ts:playground-globals.d.ts');
-        }
 
         // 监听内容变化
         editor.onDidChangeModelContent(() => {
@@ -169,18 +138,12 @@ export default {
           editorContainer.value.style.height = props.height;
         }
         
-        // 注册Python补全提供器
-        pythonCompletionProvider = registerPythonCompletionProvider(monaco);
-        console.log('[MonacoEditor] Python补全提供器已注册');
-        
-        // 移动端：添加触摸缩放来调整字体大小（丝滑连续缩放）
+        // 移动端：添加触摸缩放来调整字体大小
         if (window.innerWidth <= 768 && editorContainer.value) {
           let initialDistance = 0;
           let initialFontSize = defaultOptions.fontSize || 14;
           const minFontSize = 8;
-          const maxFontSize = 30;
-          let rafId = null; // 使用 requestAnimationFrame 优化性能
-          let lastFontSize = initialFontSize;
+          const maxFontSize = 24;
           
           const getTouchDistance = (touch1, touch2) => {
             const dx = touch1.clientX - touch2.clientX;
@@ -192,50 +155,27 @@ export default {
             if (e.touches.length === 2 && editor) {
               initialDistance = getTouchDistance(e.touches[0], e.touches[1]);
               initialFontSize = editor.getOption(monaco.editor.EditorOption.fontSize);
-              lastFontSize = initialFontSize;
             }
           };
           
           touchHandlers.move = (e) => {
             if (e.touches.length === 2 && editor) {
               e.preventDefault(); // 防止页面缩放
-              
               const currentDistance = getTouchDistance(e.touches[0], e.touches[1]);
               const scale = currentDistance / initialDistance;
-              
-              // 使用连续缩放，保留小数以获得丝滑效果
-              const newFontSize = initialFontSize * scale;
+              const newFontSize = Math.round(initialFontSize * scale);
               
               // 限制字体大小范围
               const clampedFontSize = Math.max(minFontSize, Math.min(maxFontSize, newFontSize));
               
-              // 使用 requestAnimationFrame 优化性能，避免频繁更新
-              if (rafId) {
-                cancelAnimationFrame(rafId);
+              if (clampedFontSize !== editor.getOption(monaco.editor.EditorOption.fontSize)) {
+                editor.updateOptions({ fontSize: clampedFontSize });
               }
-              
-              // 只有当变化超过 0.5 时才更新（减少不必要的更新）
-              if (Math.abs(clampedFontSize - lastFontSize) >= 0.5) {
-                rafId = requestAnimationFrame(() => {
-                  editor.updateOptions({ fontSize: Math.round(clampedFontSize) });
-                  lastFontSize = clampedFontSize;
-                });
-              }
-            }
-          };
-          
-          touchHandlers.end = () => {
-            // 清理 RAF
-            if (rafId) {
-              cancelAnimationFrame(rafId);
-              rafId = null;
             }
           };
           
           editorContainer.value.addEventListener('touchstart', touchHandlers.start, { passive: false });
           editorContainer.value.addEventListener('touchmove', touchHandlers.move, { passive: false });
-          editorContainer.value.addEventListener('touchend', touchHandlers.end, { passive: true });
-          editorContainer.value.addEventListener('touchcancel', touchHandlers.end, { passive: true });
         }
       } catch (error) {
         console.error('Monaco Editor初始化失败:', error);
@@ -266,17 +206,6 @@ export default {
       updateTheme(newTheme);
     });
 
-    // 监听语言变化
-    watch(() => props.language, (newLanguage) => {
-      if (editor && monaco) {
-        const model = editor.getModel();
-        if (model) {
-          monaco.editor.setModelLanguage(model, newLanguage);
-          console.log('[MonacoEditor] 语言已切换为:', newLanguage);
-        }
-      }
-    });
-
     watch(() => props.height, (newHeight) => {
       if (editorContainer.value) {
         editorContainer.value.style.height = newHeight;
@@ -291,15 +220,10 @@ export default {
     });
 
     onBeforeUnmount(() => {
-      // 清理Python补全提供器
-      disposePythonCompletionProvider(pythonCompletionProvider);
-      
       // 清理触摸事件监听器
       if (editorContainer.value && touchHandlers.start && touchHandlers.move) {
         editorContainer.value.removeEventListener('touchstart', touchHandlers.start);
         editorContainer.value.removeEventListener('touchmove', touchHandlers.move);
-        editorContainer.value.removeEventListener('touchend', touchHandlers.end);
-        editorContainer.value.removeEventListener('touchcancel', touchHandlers.end);
       }
       if (editor) {
         editor.dispose();

web-front/src/components/TestPanel.vue

@@ -1,364 +0,0 @@
-<!-- 测试参数和结果 Tab 面板组件 -->
-<template>
-  <div class="test-panel">
-    <el-tabs v-model="activeTab" class="test-panel-tabs" type="border-card">
-      <!-- 测试Tab -->
-      <el-tab-pane label="测试" name="test">
-        <template #label>
-          <span class="tab-label">
-            <el-icon><Stopwatch /></el-icon>
-            <span style="margin-left: 4px;">测试</span>
-          </span>
-        </template>
-        
-        <!-- 测试参数 -->
-        <div class="test-params-section">
-          <el-form :model="testParams" label-width="0px" size="small">
-            <el-form-item label="">
-              <el-autocomplete
-                v-model="testParams.shareUrl"
-                :fetch-suggestions="queryUrlHistory"
-                placeholder="请输入分享链接"
-                clearable
-                style="width: 100%;"
-                @select="handleUrlSelect"
-              >
-                <template #suffix>
-                  <el-icon><Link /></el-icon>
-                </template>
-              </el-autocomplete>
-            </el-form-item>
-            <el-form-item label="">
-              <el-input
-                v-model="testParams.pwd"
-                placeholder="密码（可选）"
-                clearable
-              >
-                <template #prefix>
-                  <el-icon><Lock /></el-icon>
-                </template>
-              </el-input>
-            </el-form-item>
-            <el-form-item label="">
-              <el-radio-group v-model="testParams.method" size="small">
-                <el-radio label="parse">parse</el-radio>
-                <el-radio label="parseFileList">parseFileList</el-radio>
-              </el-radio-group>
-            </el-form-item>
-            <el-form-item>
-              <el-button
-                type="primary"
-                :loading="testing"
-                @click="$emit('execute-test')"
-                style="width: 100%"
-              >
-                执行测试
-              </el-button>
-            </el-form-item>
-          </el-form>
-        </div>
-        
-        <!-- 执行结果 -->
-        <div class="test-result-section">
-          <div class="section-header">
-            <span>执行结果</span>
-            <el-button 
-              v-if="testResult" 
-              text 
-              size="small" 
-              icon="Delete" 
-              @click="$emit('clear-result')"
-            >
-              清空
-            </el-button>
-          </div>
-          
-          <div v-if="testResult" class="result-content">
-            <el-alert
-              :type="testResult.success ? 'success' : 'error'"
-              :title="testResult.success ? '执行成功' : '执行失败'"
-              :closable="false"
-              style="margin-bottom: 10px"
-            />
-            
-            <div v-if="testResult.success" class="result-section">
-              <div class="section-title">结果数据：</div>
-              <el-input
-                v-if="testResult.result"
-                type="textarea"
-                :model-value="testResult.result"
-                readonly
-                :autosize="{ minRows: 2, maxRows: 8 }"
-                class="result-textarea"
-              />
-              <div v-else class="empty-data">（无数据）</div>
-            </div>
-
-            <div v-if="testResult.error" class="result-section">
-              <div class="section-title">错误信息：</div>
-              <el-alert type="error" :title="testResult.error" :closable="false" />
-              <div v-if="testResult.stackTrace" class="stack-trace">
-                <el-collapse>
-                  <el-collapse-item title="查看堆栈信息" name="stack">
-                    <pre>{{ testResult.stackTrace }}</pre>
-                  </el-collapse-item>
-                </el-collapse>
-              </div>
-            </div>
-
-            <div v-if="testResult.executionTime" class="result-section">
-              <div class="section-title">执行时间：</div>
-              <div>{{ testResult.executionTime }}ms</div>
-            </div>
-          </div>
-          <div v-else class="empty-result">
-            <el-empty description="暂无执行结果" :image-size="60" />
-          </div>
-        </div>
-      </el-tab-pane>
-      
-      <!-- 问题Tab -->
-      <el-tab-pane name="problems">
-        <template #label>
-          <span class="tab-label">
-            <el-icon><WarningFilled /></el-icon>
-            问题
-            <el-badge v-if="codeProblems.length > 0" :value="codeProblems.length" style="margin-left: 5px;" />
-          </span>
-        </template>
-        
-        <div v-if="codeProblems.length > 0" class="problems-list">
-          <div
-            v-for="(problem, index) in codeProblems"
-            :key="index"
-            :class="[
-              'problem-item',
-              problem.severity === 8 ? 'problem-error' : problem.severity === 4 ? 'problem-warning' : 'problem-info'
-            ]"
-            @click="$emit('goto-problem', problem)"
-          >
-            <div class="problem-header">
-              <el-icon :size="16">
-                <WarningFilled v-if="problem.severity === 8" />
-                <Warning v-else-if="problem.severity === 4" />
-                <InfoFilled v-else />
-              </el-icon>
-              <span class="problem-line">行 {{problem.startLineNumber}}</span>
-            </div>
-            <div class="problem-message">{{ problem.message }}</div>
-          </div>
-        </div>
-        <div v-else class="empty-problems">
-          <el-empty description="暂无代码问题" :image-size="60" />
-        </div>
-      </el-tab-pane>
-    </el-tabs>
-  </div>
-</template>
-
-<script setup>
-import { ref, computed } from 'vue';
-import { Stopwatch, WarningFilled, Warning, InfoFilled, Link, Lock } from '@element-plus/icons-vue';
-import JsonViewer from 'vue3-json-viewer';
-import 'vue3-json-viewer/dist/index.css';
-
-const props = defineProps({
-  testParams: {
-    type: Object,
-    required: true
-  },
-  testResult: {
-    type: Object,
-    default: null
-  },
-  testing: {
-    type: Boolean,
-    default: false
-  },
-  codeProblems: {
-    type: Array,
-    default: () => []
-  },
-  urlHistory: {
-    type: Array,
-    default: () => []
-  }
-});
-
-const emit = defineEmits(['execute-test', 'clear-result', 'goto-problem', 'update:testParams']);
-
-const activeTab = ref('test');
-
-// URL历史记录查询
-const queryUrlHistory = (queryString, cb) => {
-  const results = queryString 
-    ? props.urlHistory
-        .filter(url => url.toLowerCase().includes(queryString.toLowerCase()))
-        .map(url => ({ value: url }))
-    : props.urlHistory.map(url => ({ value: url }));
-  cb(results);
-};
-
-// 选择历史URL
-const handleUrlSelect = (item) => {
-  emit('update:testParams', { ...props.testParams, shareUrl: item.value });
-};
-</script>
-
-<style scoped>
-.test-panel {
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-}
-
-.test-panel-tabs {
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-}
-
-.test-panel-tabs :deep(.el-tabs__header) {
-  flex-shrink: 0;
-  margin-bottom: 0;
-}
-
-.test-panel-tabs :deep(.el-tabs__content) {
-  flex: 1;
-  overflow-y: auto;
-  padding: 12px;
-}
-
-.test-panel-tabs :deep(.el-tab-pane) {
-  height: 100%;
-}
-
-.tab-label {
-  display: flex;
-  align-items: center;
-  gap: 5px;
-}
-
-.test-params-section {
-  padding: 12px;
-  background: var(--el-fill-color-light);
-  border-radius: 4px;
-  margin-bottom: 12px;
-}
-
-.test-result-section {
-  padding: 12px;
-}
-
-.section-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 12px;
-  font-weight: 600;
-  color: var(--el-text-color-primary);
-}
-
-.result-content {
-  background: var(--el-bg-color);
-  padding: 12px;
-  border-radius: 4px;
-  border: 1px solid var(--el-border-color);
-}
-
-.result-section {
-  margin-bottom: 15px;
-}
-
-.result-section:last-child {
-  margin-bottom: 0;
-}
-
-.section-title {
-  font-weight: 600;
-  margin-bottom: 8px;
-  color: var(--el-text-color-primary);
-}
-
-.stack-trace {
-  margin-top: 10px;
-}
-
-.stack-trace pre {
-  background: var(--el-fill-color-light);
-  padding: 10px;
-  border-radius: 4px;
-  font-size: 12px;
-  overflow-x: auto;
-  max-height: 300px;
-}
-
-.empty-result,
-.empty-problems {
-  padding: 40px 20px;
-  text-align: center;
-}
-
-.problems-list {
-  padding: 8px;
-}
-
-.problem-item {
-  padding: 12px;
-  margin-bottom: 8px;
-  border-radius: 4px;
-  cursor: pointer;
-  transition: all 0.2s;
-  border-left: 3px solid;
-}
-
-.problem-item:hover {
-  background: var(--el-fill-color-light);
-  transform: translateX(2px);
-}
-
-.problem-error {
-  border-left-color: var(--el-color-error);
-  background: var(--el-color-error-light-9);
-}
-
-.problem-warning {
-  border-left-color: var(--el-color-warning);
-  background: var(--el-color-warning-light-9);
-}
-
-.problem-info {
-  border-left-color: var(--el-color-info);
-  background: var(--el-color-info-light-9);
-}
-
-.problem-header {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  margin-bottom: 6px;
-  font-weight: 600;
-  color: var(--el-text-color-primary);
-}
-
-.problem-line {
-  font-size: 12px;
-  color: var(--el-text-color-secondary);
-}
-
-.problem-message {
-  font-size: 13px;
-  color: var(--el-text-color-regular);
-  line-height: 1.5;
-  word-break: break-word;
-}
-
-.empty-data {
-  color: var(--el-text-color-secondary);
-  font-style: italic;
-  padding: 10px;
-  background: var(--el-fill-color-light);
-  border-radius: 4px;
-  text-align: center;
-}
-</style>

web-front/src/templates/index.js

@@ -1,104 +0,0 @@
-/**
- * 解析器模板统一导出
- * 提供 JavaScript 和 Python 解析器模板的统一接口
- */
-
-import {
-  generateJsTemplate,
-  JS_EMPTY_TEMPLATE,
-  JS_HTTP_EXAMPLE,
-  JS_REGEX_EXAMPLE
-} from './jsParserTemplate';
-
-import {
-  generatePyTemplate,
-  PY_EMPTY_TEMPLATE,
-  PY_HTTP_EXAMPLE,
-  PY_REGEX_EXAMPLE,
-  PY_SECURITY_NOTICE
-} from './pyParserTemplate';
-
-/**
- * 根据语言生成模板代码
- * @param {string} name - 解析器名称
- * @param {string} identifier - 标识符
- * @param {string} author - 作者
- * @param {string} match - URL匹配模式
- * @param {string} language - 语言类型 ('javascript' | 'python')
- * @returns {string} 模板代码
- */
-export const generateTemplate = (name, identifier, author, match, language = 'javascript') => {
-  if (language === 'python') {
-    return generatePyTemplate(name, identifier, author, match);
-  }
-  return generateJsTemplate(name, identifier, author, match);
-};
-
-/**
- * 获取默认空白模板
- * @param {string} language - 语言类型
- * @returns {string} 空白模板代码
- */
-export const getEmptyTemplate = (language = 'javascript') => {
-  if (language === 'python') {
-    return PY_EMPTY_TEMPLATE;
-  }
-  return JS_EMPTY_TEMPLATE;
-};
-
-/**
- * 获取 HTTP 请求示例
- * @param {string} language - 语言类型
- * @returns {string} HTTP 示例代码
- */
-export const getHttpExample = (language = 'javascript') => {
-  if (language === 'python') {
-    return PY_HTTP_EXAMPLE;
-  }
-  return JS_HTTP_EXAMPLE;
-};
-
-/**
- * 获取正则表达式示例
- * @param {string} language - 语言类型
- * @returns {string} 正则表达式示例代码
- */
-export const getRegexExample = (language = 'javascript') => {
-  if (language === 'python') {
-    return PY_REGEX_EXAMPLE;
-  }
-  return JS_REGEX_EXAMPLE;
-};
-
-// 导出所有模板
-export {
-  // JavaScript
-  generateJsTemplate,
-  JS_EMPTY_TEMPLATE,
-  JS_HTTP_EXAMPLE,
-  JS_REGEX_EXAMPLE,
-  // Python
-  generatePyTemplate,
-  PY_EMPTY_TEMPLATE,
-  PY_HTTP_EXAMPLE,
-  PY_REGEX_EXAMPLE,
-  PY_SECURITY_NOTICE
-};
-
-export default {
-  generateTemplate,
-  getEmptyTemplate,
-  getHttpExample,
-  getRegexExample,
-  // JavaScript
-  generateJsTemplate,
-  JS_EMPTY_TEMPLATE,
-  JS_HTTP_EXAMPLE,
-  JS_REGEX_EXAMPLE,
-  // Python
-  generatePyTemplate,
-  PY_EMPTY_TEMPLATE,
-  PY_HTTP_EXAMPLE,
-  PY_REGEX_EXAMPLE,
-  PY_SECURITY_NOTICE
-};

web-front/src/templates/jsParserTemplate.js

@@ -1,153 +0,0 @@
-/**
- * JavaScript 解析器模板
- * 包含解析器的基础模板代码
- */
-
-/**
- * 生成 JavaScript 解析器模板代码
- * @param {string} name - 解析器名称
- * @param {string} identifier - 标识符
- * @param {string} author - 作者
- * @param {string} match - URL匹配模式
- * @returns {string} JavaScript模板代码
- */
-export const generateJsTemplate = (name, identifier, author, match) => {
-  const type = identifier.toLowerCase().replace(/[^a-z0-9]/g, '_');
-  const displayName = name;
-  const description = `使用JavaScript实现的${name}解析器`;
-  
-  return `// ==UserScript==
-// @name         ${name}
-// @type         ${type}
-// @displayName  ${displayName}
-// @description  ${description}
-// @match        ${match || 'https?://example.com/s/(?<KEY>\\\\w+)'}
-// @author       ${author || 'yourname'}
-// @version      1.0.0
-// ==/UserScript==
-
-/**
- * 解析单个文件下载链接
- * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息
- * @param {JsHttpClient} http - HTTP客户端
- * @param {JsLogger} logger - 日志对象
- * @returns {string} 下载链接
- */
-function parse(shareLinkInfo, http, logger) {
-    var url = shareLinkInfo.getShareUrl();
-    logger.info("开始解析: " + url);
-    
-    var response = http.get(url);
-    if (!response.isSuccess()) {
-        throw new Error("请求失败: " + response.statusCode());
-    }
-    
-    var html = response.body();
-    // 这里添加你的解析逻辑
-    // 例如：使用正则表达式提取下载链接
-    
-    return "https://example.com/download/file.zip";
-}
-
-/**
- * 解析文件列表（可选）
- * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息
- * @param {JsHttpClient} http - HTTP客户端
- * @param {JsLogger} logger - 日志对象
- * @returns {Array} 文件信息数组
- */
-function parseFileList(shareLinkInfo, http, logger) {
-    var dirId = shareLinkInfo.getOtherParam("dirId") || "0";
-    logger.info("解析文件列表，目录ID: " + dirId);
-    
-    // 这里添加你的文件列表解析逻辑
-    var fileList = [];
-    
-    return fileList;
-}`;
-};
-
-/**
- * JavaScript 解析器的默认空白模板
- */
-export const JS_EMPTY_TEMPLATE = `// ==UserScript==
-// @name         新解析器
-// @type         new_parser
-// @displayName  新解析器
-// @description  解析器描述
-// @match        https?://example.com/s/(?<KEY>\\w+)
-// @author       yourname
-// @version      1.0.0
-// ==/UserScript==
-
-function parse(shareLinkInfo, http, logger) {
-    var url = shareLinkInfo.getShareUrl();
-    logger.info("开始解析: " + url);
-    
-    // 在这里编写你的解析逻辑
-    
-    return "";
-}
-`;
-
-/**
- * JavaScript HTTP 请求示例模板
- */
-export const JS_HTTP_EXAMPLE = `// HTTP 请求示例
-
-// GET 请求
-var response = http.get("https://api.example.com/data");
-if (response.isSuccess()) {
-    var json = JSON.parse(response.body());
-    logger.info("获取数据成功");
-}
-
-// POST 请求（表单数据）
-var formData = {
-    "key": "value",
-    "name": "test"
-};
-var postResponse = http.post("https://api.example.com/submit", formData);
-
-// POST 请求（JSON数据）
-var jsonData = JSON.stringify({ id: 1, name: "test" });
-var headers = { "Content-Type": "application/json" };
-var jsonResponse = http.postJson("https://api.example.com/api", jsonData, headers);
-
-// 自定义请求头
-var customHeaders = {
-    "User-Agent": "Mozilla/5.0",
-    "Referer": "https://example.com"
-};
-var customResponse = http.getWithHeaders("https://api.example.com/data", customHeaders);
-`;
-
-/**
- * JavaScript 正则表达式示例
- */
-export const JS_REGEX_EXAMPLE = `// 正则表达式示例
-
-var html = response.body();
-
-// 匹配下载链接
-var downloadMatch = html.match(/href=["']([^"']*\\.zip)["']/);
-if (downloadMatch) {
-    var downloadUrl = downloadMatch[1];
-}
-
-// 匹配JSON数据
-var jsonMatch = html.match(/var data = (\\{[^}]+\\})/);
-if (jsonMatch) {
-    var data = JSON.parse(jsonMatch[1]);
-}
-
-// 全局匹配
-var allLinks = html.match(/href=["']([^"']+)["']/g);
-`;
-
-export default {
-  generateJsTemplate,
-  JS_EMPTY_TEMPLATE,
-  JS_HTTP_EXAMPLE,
-  JS_REGEX_EXAMPLE
-};

web-front/src/templates/pyParserTemplate.js

@@ -1,234 +0,0 @@
-/**
- * Python 解析器模板
- * 包含解析器的基础模板代码
- */
-
-/**
- * 生成 Python 解析器模板代码
- * @param {string} name - 解析器名称
- * @param {string} identifier - 标识符
- * @param {string} author - 作者
- * @param {string} match - URL匹配模式
- * @returns {string} Python模板代码
- */
-export const generatePyTemplate = (name, identifier, author, match) => {
-  const type = identifier.toLowerCase().replace(/[^a-z0-9]/g, '_');
-  const displayName = name;
-  const description = `使用Python实现的${name}解析器`;
-  
-  return `# ==UserScript==
-# @name         ${name}
-# @type         ${type}
-# @displayName  ${displayName}
-# @description  ${description}
-# @match        ${match || 'https?://example.com/s/(?<KEY>\\\\w+)'}
-# @author       ${author || 'yourname'}
-# @version      1.0.0
-# ==/UserScript==
-
-"""
-${name}解析器 - Python实现
-使用GraalPy运行，提供与JavaScript解析器相同的功能
-
-可用模块：
-- requests: HTTP请求库 (已内置，支持 get/post/put/delete 等)
-- re: 正则表达式
-- json: JSON处理
-- base64: Base64编解码
-- hashlib: 哈希算法
-
-内置对象：
-- share_link_info: 分享链接信息
-- http: 底层HTTP客户端
-- logger: 日志记录器
-- crypto: 加密工具 (md5/sha1/sha256/aes/base64)
-"""
-
-import requests
-import re
-import json
-
-
-def parse(share_link_info, http, logger):
-    """
-    解析单个文件下载链接
-    
-    Args:
-        share_link_info: 分享链接信息对象
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        str: 直链下载地址
-    """
-    url = share_link_info.get_share_url()
-    logger.info(f"开始解析: {url}")
-    
-    # 使用 requests 库发起请求（推荐）
-    response = requests.get(url, headers={
-        "Referer": url
-    })
-    
-    if not response.ok:
-        raise Exception(f"请求失败: {response.status_code}")
-    
-    html = response.text
-    
-    # 示例：使用正则表达式提取下载链接
-    # match = re.search(r'download_url["\\':]\s*["\\']([^"\\'>]+)', html)
-    # if match:
-    #     return match.group(1)
-    
-    return "https://example.com/download/file.zip"
-
-
-def parse_file_list(share_link_info, http, logger):
-    """
-    解析文件列表（可选）
-    
-    Args:
-        share_link_info: 分享链接信息对象
-        http: HTTP客户端
-        logger: 日志记录器
-    
-    Returns:
-        list: 文件信息列表
-    """
-    dir_id = share_link_info.get_other_param("dirId") or "0"
-    logger.info(f"解析文件列表，目录ID: {dir_id}")
-    
-    file_list = []
-    
-    return file_list
-`;
-};
-
-/**
- * Python 解析器的默认空白模板
- */
-export const PY_EMPTY_TEMPLATE = `# ==UserScript==
-# @name         新解析器
-# @type         new_parser
-# @displayName  新解析器
-# @description  解析器描述
-# @match        https?://example.com/s/(?<KEY>\\w+)
-# @author       yourname
-# @version      1.0.0
-# ==/UserScript==
-
-import requests
-import re
-import json
-
-
-def parse(share_link_info, http, logger):
-    """解析单个文件下载链接"""
-    url = share_link_info.get_share_url()
-    logger.info(f"开始解析: {url}")
-    
-    # 在这里编写你的解析逻辑
-    
-    return ""
-`;
-
-/**
- * Python HTTP 请求示例模板
- */
-export const PY_HTTP_EXAMPLE = `# HTTP 请求示例
-
-import requests
-import json
-
-# GET 请求
-response = requests.get("https://api.example.com/data")
-if response.ok:
-    data = response.json()
-    logger.info("获取数据成功")
-
-# POST 请求（表单数据）
-form_data = {
-    "key": "value",
-    "name": "test"
-}
-post_response = requests.post("https://api.example.com/submit", data=form_data)
-
-# POST 请求（JSON数据）
-json_data = {"id": 1, "name": "test"}
-json_response = requests.post(
-    "https://api.example.com/api",
-    json=json_data,
-    headers={"Content-Type": "application/json"}
-)
-
-# 自定义请求头
-custom_headers = {
-    "User-Agent": "Mozilla/5.0",
-    "Referer": "https://example.com"
-}
-custom_response = requests.get("https://api.example.com/data", headers=custom_headers)
-
-# 会话保持 Cookie
-session = requests.Session()
-session.get("https://example.com/login")  # 获取 Cookie
-session.post("https://example.com/api")   # 自动带上 Cookie
-`;
-
-/**
- * Python 正则表达式示例
- */
-export const PY_REGEX_EXAMPLE = `# 正则表达式示例
-
-import re
-
-html = response.text
-
-# 匹配下载链接
-download_match = re.search(r'href=["\\']([^"\\']*.zip)["\\'\\']', html)
-if download_match:
-    download_url = download_match.group(1)
-
-# 匹配JSON数据
-json_match = re.search(r'var data = (\\{[^}]+\\})', html)
-if json_match:
-    data = json.loads(json_match.group(1))
-
-# 查找所有匹配项
-all_links = re.findall(r'href=["\\']([^"\\']]+)["\\'\\']', html)
-
-# 使用命名分组
-pattern = r'<a href="(?P<url>[^"]+)">(?P<text>[^<]+)</a>'
-for match in re.finditer(pattern, html):
-    url = match.group('url')
-    text = match.group('text')
-`;
-
-/**
- * Python 安全提示
- */
-export const PY_SECURITY_NOTICE = `# ⚠️ Python 安全限制说明
-#
-# 以下操作被禁止（安全策略限制）：
-# - os.system()     系统命令执行
-# - os.popen()      进程创建
-# - os.remove()     删除文件
-# - os.rmdir()      删除目录
-# - subprocess.*    子进程操作
-# - open() 文件写入 (read模式允许)
-#
-# 允许的操作：
-# - requests.*      网络请求
-# - re.*           正则表达式
-# - json.*         JSON处理
-# - base64.*       Base64编解码
-# - hashlib.*      哈希算法
-# - os.getcwd()    获取当前目录
-# - os.path.*      路径操作
-`;
-
-export default {
-  generatePyTemplate,
-  PY_EMPTY_TEMPLATE,
-  PY_HTTP_EXAMPLE,
-  PY_REGEX_EXAMPLE,
-  PY_SECURITY_NOTICE
-};

web-front/src/utils/monacoTypes.js

@@ -1,7 +1,6 @@
 /**
  * Monaco Editor 代码补全配置工具
  * 基于 types.js 提供完整的代码补全支持
- * 支持 JavaScript 和 Python 两种语言
  */
 
 /**
@@ -46,9 +45,6 @@ export async function configureMonacoTypes(monaco) {
 
   // 注册代码补全提供者
   registerCompletionProvider(monaco);
-  
-  // 注册Python语言补全提供者
-  registerPythonCompletionProvider(monaco);
 }
 
 /**
@@ -303,613 +299,6 @@ function registerCompletionProvider(monaco) {
   });
 }
 
-/**
- * 注册Python语言补全提供者
- * 提供 requests 库、内置对象和常用模块的代码补全
- */
-function registerPythonCompletionProvider(monaco) {
-  monaco.languages.registerCompletionItemProvider('python', {
-    triggerCharacters: ['.', '(', '"', "'"],
-    provideCompletionItems: (model, position) => {
-      const word = model.getWordUntilPosition(position);
-      const range = {
-        startLineNumber: position.lineNumber,
-        endLineNumber: position.lineNumber,
-        startColumn: word.startColumn,
-        endColumn: word.endColumn
-      };
-
-      // 获取当前行内容以判断上下文
-      const lineContent = model.getLineContent(position.lineNumber);
-      const textBeforeCursor = lineContent.substring(0, position.column - 1);
-      
-      const suggestions = [];
-      
-      // ===== requests 库补全 =====
-      if (textBeforeCursor.endsWith('requests.') || textBeforeCursor.match(/requests\s*\.\s*$/)) {
-        suggestions.push(
-          {
-            label: 'get',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get(${1:url}, params=${2:None}, headers=${3:None})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 GET 请求\n\n参数:\n- url: 请求URL\n- params: URL参数字典\n- headers: 请求头字典\n\n返回: Response 对象',
-            range
-          },
-          {
-            label: 'post',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'post(${1:url}, data=${2:None}, json=${3:None}, headers=${4:None})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 POST 请求\n\n参数:\n- url: 请求URL\n- data: 表单数据\n- json: JSON数据\n- headers: 请求头字典\n\n返回: Response 对象',
-            range
-          },
-          {
-            label: 'put',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'put(${1:url}, data=${2:None})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 PUT 请求',
-            range
-          },
-          {
-            label: 'delete',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'delete(${1:url})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 DELETE 请求',
-            range
-          },
-          {
-            label: 'patch',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'patch(${1:url}, data=${2:None})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 PATCH 请求',
-            range
-          },
-          {
-            label: 'head',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'head(${1:url})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 HEAD 请求',
-            range
-          },
-          {
-            label: 'Session',
-            kind: monaco.languages.CompletionItemKind.Class,
-            insertText: 'Session()',
-            documentation: '创建一个会话对象，可以跨请求保持 cookies 和 headers',
-            range
-          },
-          {
-            label: 'url_encode',
-            kind: monaco.languages.CompletionItemKind.Function,
-            insertText: 'url_encode(${1:text})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'URL 编码',
-            range
-          },
-          {
-            label: 'url_decode',
-            kind: monaco.languages.CompletionItemKind.Function,
-            insertText: 'url_decode(${1:text})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'URL 解码',
-            range
-          }
-        );
-      }
-      // Response 对象补全
-      else if (textBeforeCursor.match(/\.\s*$/) && (
-        textBeforeCursor.includes('response') || 
-        textBeforeCursor.includes('resp') || 
-        textBeforeCursor.includes('res') ||
-        textBeforeCursor.match(/requests\.(get|post|put|delete|patch|head)\([^)]*\)\s*\./)
-      )) {
-        suggestions.push(
-          {
-            label: 'text',
-            kind: monaco.languages.CompletionItemKind.Property,
-            insertText: 'text',
-            documentation: '响应的文本内容',
-            range
-          },
-          {
-            label: 'content',
-            kind: monaco.languages.CompletionItemKind.Property,
-            insertText: 'content',
-            documentation: '响应的二进制内容',
-            range
-          },
-          {
-            label: 'json',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'json()',
-            documentation: '解析响应为 JSON 对象',
-            range
-          },
-          {
-            label: 'status_code',
-            kind: monaco.languages.CompletionItemKind.Property,
-            insertText: 'status_code',
-            documentation: 'HTTP 状态码',
-            range
-          },
-          {
-            label: 'ok',
-            kind: monaco.languages.CompletionItemKind.Property,
-            insertText: 'ok',
-            documentation: '请求是否成功 (status_code < 400)',
-            range
-          },
-          {
-            label: 'headers',
-            kind: monaco.languages.CompletionItemKind.Property,
-            insertText: 'headers',
-            documentation: '响应头字典',
-            range
-          },
-          {
-            label: 'raise_for_status',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'raise_for_status()',
-            documentation: '如果响应状态码表示错误，则抛出异常',
-            range
-          }
-        );
-      }
-      // share_link_info 对象补全
-      else if (textBeforeCursor.endsWith('share_link_info.')) {
-        suggestions.push(
-          {
-            label: 'get_share_url',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_share_url()',
-            documentation: '获取分享URL',
-            range
-          },
-          {
-            label: 'get_share_key',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_share_key()',
-            documentation: '获取分享Key',
-            range
-          },
-          {
-            label: 'get_share_password',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_share_password()',
-            documentation: '获取分享密码',
-            range
-          },
-          {
-            label: 'get_type',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_type()',
-            documentation: '获取网盘类型',
-            range
-          },
-          {
-            label: 'get_pan_name',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_pan_name()',
-            documentation: '获取网盘名称',
-            range
-          },
-          {
-            label: 'get_other_param',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_other_param(${1:key})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '获取其他参数',
-            range
-          }
-        );
-      }
-      // http 对象补全（Python 风格下划线命名）
-      else if (textBeforeCursor.endsWith('http.')) {
-        suggestions.push(
-          {
-            label: 'get',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get(${1:url})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 GET 请求',
-            range
-          },
-          {
-            label: 'get_with_redirect',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_with_redirect(${1:url})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 GET 请求并跟随重定向',
-            range
-          },
-          {
-            label: 'get_no_redirect',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'get_no_redirect(${1:url})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 GET 请求但不跟随重定向',
-            range
-          },
-          {
-            label: 'post',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'post(${1:url}, ${2:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 POST 请求',
-            range
-          },
-          {
-            label: 'post_json',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'post_json(${1:url}, ${2:json_data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '发起 POST 请求（JSON 数据）',
-            range
-          },
-          {
-            label: 'put_header',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'put_header(${1:name}, ${2:value})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '设置请求头',
-            range
-          },
-          {
-            label: 'put_headers',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'put_headers(${1:headers_dict})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '批量设置请求头',
-            range
-          },
-          {
-            label: 'set_timeout',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'set_timeout(${1:seconds})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '设置请求超时时间（秒）',
-            range
-          },
-          {
-            label: 'url_encode',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'url_encode(${1:text})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'URL 编码',
-            range
-          },
-          {
-            label: 'url_decode',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'url_decode(${1:text})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'URL 解码',
-            range
-          }
-        );
-      }
-      // logger 对象补全
-      else if (textBeforeCursor.endsWith('logger.')) {
-        suggestions.push(
-          {
-            label: 'info',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'info(${1:message})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '记录信息日志',
-            range
-          },
-          {
-            label: 'debug',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'debug(${1:message})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '记录调试日志',
-            range
-          },
-          {
-            label: 'warn',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'warn(${1:message})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '记录警告日志',
-            range
-          },
-          {
-            label: 'error',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'error(${1:message})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '记录错误日志',
-            range
-          }
-        );
-      }
-      // crypto 加密工具补全
-      else if (textBeforeCursor.endsWith('crypto.')) {
-        suggestions.push(
-          {
-            label: 'md5',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'md5(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'MD5 加密（返回32位小写）',
-            range
-          },
-          {
-            label: 'md5_16',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'md5_16(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'MD5 加密（返回16位小写）',
-            range
-          },
-          {
-            label: 'sha1',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'sha1(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'SHA-1 加密',
-            range
-          },
-          {
-            label: 'sha256',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'sha256(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'SHA-256 加密',
-            range
-          },
-          {
-            label: 'base64_encode',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'base64_encode(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'Base64 编码',
-            range
-          },
-          {
-            label: 'base64_decode',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'base64_decode(${1:data})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'Base64 解码',
-            range
-          },
-          {
-            label: 'aes_encrypt',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'aes_encrypt(${1:data}, ${2:key}, ${3:iv})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'AES 加密',
-            range
-          },
-          {
-            label: 'aes_decrypt',
-            kind: monaco.languages.CompletionItemKind.Method,
-            insertText: 'aes_decrypt(${1:data}, ${2:key}, ${3:iv})',
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'AES 解密',
-            range
-          }
-        );
-      }
-      // 全局补全
-      else {
-        // import 语句补全
-        suggestions.push(
-          {
-            label: 'import requests',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'import requests',
-            documentation: '导入 requests HTTP 库',
-            range
-          },
-          {
-            label: 'import re',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'import re',
-            documentation: '导入正则表达式模块',
-            range
-          },
-          {
-            label: 'import json',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'import json',
-            documentation: '导入 JSON 模块',
-            range
-          },
-          {
-            label: 'import base64',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'import base64',
-            documentation: '导入 Base64 编码模块',
-            range
-          },
-          {
-            label: 'import hashlib',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'import hashlib',
-            documentation: '导入哈希算法模块',
-            range
-          },
-          {
-            label: 'from urllib.parse import urlencode, quote, unquote',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: 'from urllib.parse import urlencode, quote, unquote',
-            documentation: '导入 URL 处理函数',
-            range
-          }
-        );
-        
-        // 全局变量补全
-        suggestions.push(
-          {
-            label: 'requests',
-            kind: monaco.languages.CompletionItemKind.Module,
-            insertText: 'requests',
-            documentation: 'HTTP 请求库，支持 get, post, put, delete 等方法',
-            range
-          },
-          {
-            label: 'share_link_info',
-            kind: monaco.languages.CompletionItemKind.Variable,
-            insertText: 'share_link_info',
-            documentation: '分享链接信息对象，包含 URL、密码等信息',
-            range
-          },
-          {
-            label: 'http',
-            kind: monaco.languages.CompletionItemKind.Variable,
-            insertText: 'http',
-            documentation: 'HTTP 客户端对象（底层 Java 实现）',
-            range
-          },
-          {
-            label: 'logger',
-            kind: monaco.languages.CompletionItemKind.Variable,
-            insertText: 'logger',
-            documentation: '日志记录器',
-            range
-          },
-          {
-            label: 'crypto',
-            kind: monaco.languages.CompletionItemKind.Variable,
-            insertText: 'crypto',
-            documentation: '加密工具对象，提供 MD5、SHA、AES、Base64 等功能',
-            range
-          }
-        );
-        
-        // 函数模板补全
-        suggestions.push(
-          {
-            label: 'def parse',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'def parse(share_link_info, http, logger):',
-              '    """',
-              '    解析单个文件下载链接',
-              '    ',
-              '    Args:',
-              '        share_link_info: 分享链接信息对象',
-              '        http: HTTP 客户端',
-              '        logger: 日志记录器',
-              '    ',
-              '    Returns:',
-              '        str: 直链下载地址',
-              '    """',
-              '    url = share_link_info.get_share_url()',
-              '    logger.info(f"开始解析: {url}")',
-              '    ',
-              '    ${0}',
-              '    ',
-              '    return ""'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '创建 parse 函数模板',
-            range
-          },
-          {
-            label: 'def parse_file_list',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'def parse_file_list(share_link_info, http, logger):',
-              '    """',
-              '    解析文件列表',
-              '    ',
-              '    Args:',
-              '        share_link_info: 分享链接信息对象',
-              '        http: HTTP 客户端',
-              '        logger: 日志记录器',
-              '    ',
-              '    Returns:',
-              '        list: 文件信息列表',
-              '    """',
-              '    dir_id = share_link_info.get_other_param("dirId") or "0"',
-              '    logger.info(f"解析文件列表，目录ID: {dir_id}")',
-              '    ',
-              '    file_list = []',
-              '    ${0}',
-              '    ',
-              '    return file_list'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '创建 parse_file_list 函数模板',
-            range
-          },
-          {
-            label: 'requests.get example',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'response = requests.get(${1:url}, headers={',
-              '    "User-Agent": "Mozilla/5.0"',
-              '})',
-              'if response.ok:',
-              '    data = response.json()',
-              '    ${0}'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'requests.get 请求示例',
-            range
-          },
-          {
-            label: 'requests.post example',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'response = requests.post(${1:url}, json={',
-              '    ${2:"key": "value"}',
-              '}, headers={',
-              '    "Content-Type": "application/json"',
-              '})',
-              'if response.ok:',
-              '    result = response.json()',
-              '    ${0}'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: 'requests.post 请求示例',
-            range
-          },
-          {
-            label: 're.search example',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'import re',
-              'match = re.search(r\'${1:pattern}\', ${2:text})',
-              'if match:',
-              '    result = match.group(${3:1})',
-              '    ${0}'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '正则表达式搜索示例',
-            range
-          },
-          {
-            label: 're.findall example',
-            kind: monaco.languages.CompletionItemKind.Snippet,
-            insertText: [
-              'import re',
-              'matches = re.findall(r\'${1:pattern}\', ${2:text})',
-              'for match in matches:',
-              '    ${0}'
-            ].join('\n'),
-            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-            documentation: '正则表达式查找所有匹配示例',
-            range
-          }
-        );
-      }
-
-      return { suggestions };
-    }
-  });
-}
-
 /**
  * 从API获取types.js内容并配置
  */

web-front/src/utils/playgroundApi.js

@@ -37,23 +37,20 @@ export const playgroundApi = {
   },
 
   /**
-   * 测试执行JavaScript/Python代码
-   * @param {string} code - 代码
+   * 测试执行JavaScript代码
+   * @param {string} jsCode - JavaScript代码
    * @param {string} shareUrl - 分享链接
    * @param {string} pwd - 密码（可选）
    * @param {string} method - 测试方法：parse/parseFileList/parseById
-   * @param {string} language - 语言类型：javascript/python
    * @returns {Promise} 测试结果
    */
-  async testScript(code, shareUrl, pwd = '', method = 'parse', language = 'javascript') {
+  async testScript(jsCode, shareUrl, pwd = '', method = 'parse') {
     try {
       const response = await axiosInstance.post('/v2/playground/test', {
-        jsCode: code, // 兼容后端旧字段名
-        code,
+        jsCode,
         shareUrl,
         pwd,
-        method,
-        language
+        method
       });
       // 框架会自动包装成JsonResult，需要从data字段获取
       if (response.data && response.data.data) {
@@ -86,21 +83,6 @@ export const playgroundApi = {
     }
   },
 
-  /**
-   * 获取types.pyi文件内容（Python类型提示）
-   * @returns {Promise<string>} types.pyi内容
-   */
-  async getTypesPyi() {
-    try {
-      const response = await axiosInstance.get('/v2/playground/types.pyi', {
-        responseType: 'text'
-      });
-      return response.data;
-    } catch (error) {
-      throw new Error(error.response?.data?.error || error.message || '获取types.pyi失败');
-    }
-  },
-
   /**
    * 获取解析器列表
    */
@@ -124,18 +106,10 @@ export const playgroundApi = {
 
   /**
    * 保存解析器
-   * @param {string} code - 代码
-   * @param {string} language - 语言类型：javascript/python
-   * @param {boolean} forceOverwrite - 是否强制覆盖已存在的解析器
    */
-  async saveParser(code, language = 'javascript', forceOverwrite = false) {
+  async saveParser(jsCode) {
     try {
-      const response = await axiosInstance.post('/v2/playground/parsers', { 
-        jsCode: code, // 兼容后端旧字段名
-        code,
-        language,
-        forceOverwrite
-      });
+      const response = await axiosInstance.post('/v2/playground/parsers', { jsCode });
       // 框架会自动包装成JsonResult
       if (response.data && response.data.data) {
         return {
@@ -147,20 +121,6 @@ export const playgroundApi = {
       }
       return response.data;
     } catch (error) {
-      // 检查是否是type已存在的错误（需要覆盖确认）
-      const errorData = error.response?.data;
-      if (errorData && errorData.existingId && errorData.existingType) {
-        // 返回包含existingId的错误信息，供前端显示覆盖确认对话框
-        return {
-          code: errorData.code || 400,
-          msg: errorData.msg || errorData.error || '解析器已存在',
-          error: errorData.msg || errorData.error,
-          existingId: errorData.existingId,
-          existingType: errorData.existingType,
-          success: false
-        };
-      }
-      
       const errorMsg = error.response?.data?.data?.error || 
                       error.response?.data?.error || 
                       error.response?.data?.msg || 
@@ -172,19 +132,10 @@ export const playgroundApi = {
 
   /**
    * 更新解析器
-   * @param {number} id - 解析器ID
-   * @param {string} code - 代码
-   * @param {boolean} enabled - 是否启用
-   * @param {string} language - 语言类型：javascript/python
    */
-  async updateParser(id, code, enabled = true, language = 'javascript') {
+  async updateParser(id, jsCode, enabled = true) {
     try {
-      const response = await axiosInstance.put(`/v2/playground/parsers/${id}`, { 
-        jsCode: code, // 兼容后端旧字段名
-        code,
-        enabled,
-        language
-      });
+      const response = await axiosInstance.put(`/v2/playground/parsers/${id}`, { jsCode, enabled });
       return response.data;
     } catch (error) {
       throw new Error(error.response?.data?.error || error.message || '更新解析器失败');
@@ -224,20 +175,4 @@ export const playgroundApi = {
     }
   },
 
-  /**
-   * 获取示例解析器代码
-   * @param {string} language - 语言类型：javascript/python
-   * @returns {Promise<string>} 示例代码
-   */
-  async getExampleParser(language = 'javascript') {
-    try {
-      const response = await axiosInstance.get(`/v2/playground/example/${language}`, {
-        responseType: 'text'
-      });
-      return response.data;
-    } catch (error) {
-      throw new Error(error.response?.data?.error || error.message || `获取${language}示例失败`);
-    }
-  },
-
 };

web-front/src/utils/pylspClient.js

@@ -1,410 +0,0 @@
-/**
- * Python LSP (pylsp/jedi) WebSocket 客户端
- * 
- * 通过 WebSocket 连接到后端 pylsp 桥接服务，
- * 提供实时代码检查、自动完成、悬停提示等功能。
- * 
- * @author QAIU
- */
-
-import SockJS from 'sockjs-client';
-
-// LSP 消息类型
-const LSP_METHODS = {
-  INITIALIZE: 'initialize',
-  INITIALIZED: 'initialized',
-  TEXT_DOCUMENT_DID_OPEN: 'textDocument/didOpen',
-  TEXT_DOCUMENT_DID_CHANGE: 'textDocument/didChange',
-  TEXT_DOCUMENT_DID_CLOSE: 'textDocument/didClose',
-  TEXT_DOCUMENT_COMPLETION: 'textDocument/completion',
-  TEXT_DOCUMENT_HOVER: 'textDocument/hover',
-  TEXT_DOCUMENT_DIAGNOSTICS: 'textDocument/publishDiagnostics',
-  SHUTDOWN: 'shutdown',
-  EXIT: 'exit'
-};
-
-// 诊断严重程度
-const DiagnosticSeverity = {
-  Error: 1,
-  Warning: 2,
-  Information: 3,
-  Hint: 4
-};
-
-/**
- * pylsp WebSocket 客户端类
- */
-class PylspClient {
-  constructor(options = {}) {
-    this.wsUrl = options.wsUrl || this._getDefaultWsUrl();
-    this.ws = null;
-    this.requestId = 1;
-    this.pendingRequests = new Map();
-    this.documentUri = 'file:///playground.py';
-    this.documentVersion = 0;
-    
-    // 回调函数
-    this.onDiagnostics = options.onDiagnostics || (() => {});
-    this.onConnected = options.onConnected || (() => {});
-    this.onDisconnected = options.onDisconnected || (() => {});
-    this.onError = options.onError || (() => {});
-    
-    // 状态
-    this.connected = false;
-    this.initialized = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 3;
-    this.reconnectDelay = 2000;
-  }
-  
-  /**
-   * 获取默认 WebSocket URL
-   * SockJS 客户端需要使用 HTTP/HTTPS URL，而不是 WS/WSS
-   */
-  _getDefaultWsUrl() {
-    const protocol = window.location.protocol; // http: 或 https:
-    const host = window.location.host;
-    return `${protocol}//${host}/v2/ws/pylsp`;
-  }
-  
-  /**
-   * 连接到 pylsp 服务
-   */
-  async connect() {
-    if (this.connected) {
-      console.log('[PylspClient] 已经连接');
-      return true;
-    }
-    
-    return new Promise((resolve, reject) => {
-      try {
-        console.log('[PylspClient] 正在连接:', this.wsUrl);
-        
-        // 使用 SockJS 连接（支持 WebSocket 和 fallback）
-        this.ws = new SockJS(this.wsUrl);
-        
-        this.ws.onopen = () => {
-          console.log('[PylspClient] WebSocket 连接成功');
-          this.connected = true;
-          this.reconnectAttempts = 0;
-          this._initialize().then(() => {
-            this.onConnected();
-            resolve(true);
-          }).catch(err => {
-            console.error('[PylspClient] 初始化失败:', err);
-            reject(err);
-          });
-        };
-        
-        this.ws.onmessage = (event) => {
-          this._handleMessage(event.data);
-        };
-        
-        this.ws.onerror = (error) => {
-          console.error('[PylspClient] WebSocket 错误:', error);
-          this.onError(error);
-        };
-        
-        this.ws.onclose = () => {
-          console.log('[PylspClient] WebSocket 连接关闭');
-          this.connected = false;
-          this.initialized = false;
-          this.onDisconnected();
-          
-          // 尝试重连
-          if (this.reconnectAttempts < this.maxReconnectAttempts) {
-            this.reconnectAttempts++;
-            console.log(`[PylspClient] 尝试重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
-            setTimeout(() => this.connect(), this.reconnectDelay);
-          }
-        };
-        
-        // 设置超时
-        setTimeout(() => {
-          if (!this.connected) {
-            reject(new Error('连接超时'));
-          }
-        }, 10000);
-        
-      } catch (error) {
-        console.error('[PylspClient] 连接失败:', error);
-        reject(error);
-      }
-    });
-  }
-  
-  /**
-   * 断开连接
-   */
-  disconnect() {
-    if (this.ws) {
-      this._sendRequest(LSP_METHODS.SHUTDOWN).then(() => {
-        this._sendNotification(LSP_METHODS.EXIT);
-        this.ws.close();
-      }).catch(() => {
-        this.ws.close();
-      });
-    }
-    this.connected = false;
-    this.initialized = false;
-  }
-  
-  /**
-   * 初始化 LSP
-   */
-  async _initialize() {
-    const params = {
-      processId: null,
-      rootUri: null,
-      capabilities: {
-        textDocument: {
-          synchronization: {
-            dynamicRegistration: false,
-            willSave: false,
-            willSaveWaitUntil: false,
-            didSave: true
-          },
-          completion: {
-            dynamicRegistration: false,
-            completionItem: {
-              snippetSupport: true,
-              commitCharactersSupport: true,
-              documentationFormat: ['markdown', 'plaintext'],
-              deprecatedSupport: true
-            }
-          },
-          hover: {
-            dynamicRegistration: false,
-            contentFormat: ['markdown', 'plaintext']
-          },
-          publishDiagnostics: {
-            relatedInformation: true
-          }
-        }
-      }
-    };
-    
-    await this._sendRequest(LSP_METHODS.INITIALIZE, params);
-    this._sendNotification(LSP_METHODS.INITIALIZED, {});
-    this.initialized = true;
-    console.log('[PylspClient] LSP 初始化完成');
-  }
-  
-  /**
-   * 打开文档
-   */
-  openDocument(content, uri = this.documentUri) {
-    if (!this.initialized) {
-      console.warn('[PylspClient] LSP 未初始化');
-      return;
-    }
-    
-    this.documentUri = uri;
-    this.documentVersion = 1;
-    
-    this._sendNotification(LSP_METHODS.TEXT_DOCUMENT_DID_OPEN, {
-      textDocument: {
-        uri: uri,
-        languageId: 'python',
-        version: this.documentVersion,
-        text: content
-      }
-    });
-  }
-  
-  /**
-   * 更新文档内容
-   */
-  updateDocument(content, uri = this.documentUri) {
-    if (!this.initialized) {
-      return;
-    }
-    
-    this.documentVersion++;
-    
-    this._sendNotification(LSP_METHODS.TEXT_DOCUMENT_DID_CHANGE, {
-      textDocument: {
-        uri: uri,
-        version: this.documentVersion
-      },
-      contentChanges: [{ text: content }]
-    });
-  }
-  
-  /**
-   * 关闭文档
-   */
-  closeDocument(uri = this.documentUri) {
-    if (!this.initialized) {
-      return;
-    }
-    
-    this._sendNotification(LSP_METHODS.TEXT_DOCUMENT_DID_CLOSE, {
-      textDocument: { uri: uri }
-    });
-  }
-  
-  /**
-   * 获取补全建议
-   */
-  async getCompletions(line, character, uri = this.documentUri) {
-    if (!this.initialized) {
-      return [];
-    }
-    
-    try {
-      const result = await this._sendRequest(LSP_METHODS.TEXT_DOCUMENT_COMPLETION, {
-        textDocument: { uri: uri },
-        position: { line, character }
-      });
-      
-      return result?.items || result || [];
-    } catch (error) {
-      console.error('[PylspClient] 获取补全失败:', error);
-      return [];
-    }
-  }
-  
-  /**
-   * 获取悬停信息
-   */
-  async getHover(line, character, uri = this.documentUri) {
-    if (!this.initialized) {
-      return null;
-    }
-    
-    try {
-      return await this._sendRequest(LSP_METHODS.TEXT_DOCUMENT_HOVER, {
-        textDocument: { uri: uri },
-        position: { line, character }
-      });
-    } catch (error) {
-      console.error('[PylspClient] 获取悬停信息失败:', error);
-      return null;
-    }
-  }
-  
-  /**
-   * 发送 LSP 请求
-   */
-  _sendRequest(method, params = {}) {
-    return new Promise((resolve, reject) => {
-      // SockJS readyState: 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED
-      if (!this.ws || this.ws.readyState !== 1) {
-        reject(new Error('WebSocket 未连接'));
-        return;
-      }
-      
-      const id = this.requestId++;
-      const message = {
-        jsonrpc: '2.0',
-        id: id,
-        method: method,
-        params: params
-      };
-      
-      this.pendingRequests.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify(message));
-      
-      // 设置超时
-      setTimeout(() => {
-        if (this.pendingRequests.has(id)) {
-          this.pendingRequests.delete(id);
-          reject(new Error(`请求超时: ${method}`));
-        }
-      }, 30000);
-    });
-  }
-  
-  /**
-   * 发送 LSP 通知（无需响应）
-   */
-  _sendNotification(method, params = {}) {
-    // SockJS readyState: 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED
-    if (!this.ws || this.ws.readyState !== 1) {
-      return;
-    }
-    
-    const message = {
-      jsonrpc: '2.0',
-      method: method,
-      params: params
-    };
-    
-    this.ws.send(JSON.stringify(message));
-  }
-  
-  /**
-   * 处理接收到的消息
-   */
-  _handleMessage(data) {
-    try {
-      const message = JSON.parse(data);
-      
-      // 响应消息
-      if (message.id !== undefined) {
-        const pending = this.pendingRequests.get(message.id);
-        if (pending) {
-          this.pendingRequests.delete(message.id);
-          if (message.error) {
-            pending.reject(new Error(message.error.message || '未知错误'));
-          } else {
-            pending.resolve(message.result);
-          }
-        }
-        return;
-      }
-      
-      // 通知消息
-      if (message.method === LSP_METHODS.TEXT_DOCUMENT_DIAGNOSTICS) {
-        this._handleDiagnostics(message.params);
-      }
-      
-    } catch (error) {
-      console.error('[PylspClient] 解析消息失败:', error);
-    }
-  }
-  
-  /**
-   * 处理诊断信息
-   */
-  _handleDiagnostics(params) {
-    const { uri, diagnostics } = params;
-    
-    // 转换为 Monaco Editor 格式
-    const monacoMarkers = diagnostics.map(d => ({
-      severity: this._convertSeverity(d.severity),
-      startLineNumber: d.range.start.line + 1,
-      startColumn: d.range.start.character + 1,
-      endLineNumber: d.range.end.line + 1,
-      endColumn: d.range.end.character + 1,
-      message: d.message,
-      source: d.source || 'pylsp'
-    }));
-    
-    this.onDiagnostics(uri, monacoMarkers);
-  }
-  
-  /**
-   * 转换诊断严重程度到 Monaco 格式
-   */
-  _convertSeverity(lspSeverity) {
-    // Monaco MarkerSeverity: Error = 8, Warning = 4, Info = 2, Hint = 1
-    switch (lspSeverity) {
-      case DiagnosticSeverity.Error: return 8;
-      case DiagnosticSeverity.Warning: return 4;
-      case DiagnosticSeverity.Information: return 2;
-      case DiagnosticSeverity.Hint: return 1;
-      default: return 4;
-    }
-  }
-}
-
-// 导出
-export {
-  PylspClient,
-  LSP_METHODS,
-  DiagnosticSeverity
-};
-
-export default PylspClient;

web-front/src/utils/pythonCompletions.js

@@ -1,336 +0,0 @@
-/**
- * Python 代码补全提供器
- * 提供关键字补全、语法模板、常用代码片段
- */
-
-// Python 关键字列表
-const PYTHON_KEYWORDS = [
-  'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
-  'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
-  'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
-  'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
-  'try', 'while', 'with', 'yield'
-];
-
-// Python 内置函数
-const PYTHON_BUILTINS = [
-  'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes',
-  'callable', 'chr', 'classmethod', 'compile', 'complex', 'delattr',
-  'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'filter',
-  'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
-  'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance',
-  'issubclass', 'iter', 'len', 'list', 'locals', 'map', 'max',
-  'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord',
-  'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round',
-  'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum',
-  'super', 'tuple', 'type', 'vars', 'zip'
-];
-
-// 代码片段模板
-const PYTHON_SNIPPETS = [
-  {
-    label: 'if',
-    kind: 'Snippet',
-    insertText: 'if ${1:condition}:\n    ${2:pass}',
-    detail: 'if语句',
-    documentation: 'if条件语句'
-  },
-  {
-    label: 'ifelse',
-    kind: 'Snippet',
-    insertText: 'if ${1:condition}:\n    ${2:pass}\nelse:\n    ${3:pass}',
-    detail: 'if-else语句',
-    documentation: 'if-else条件语句'
-  },
-  {
-    label: 'ifelif',
-    kind: 'Snippet',
-    insertText: 'if ${1:condition}:\n    ${2:pass}\nelif ${3:condition}:\n    ${4:pass}\nelse:\n    ${5:pass}',
-    detail: 'if-elif-else语句',
-    documentation: 'if-elif-else条件语句'
-  },
-  {
-    label: 'for',
-    kind: 'Snippet',
-    insertText: 'for ${1:item} in ${2:iterable}:\n    ${3:pass}',
-    detail: 'for循环',
-    documentation: 'for循环语句'
-  },
-  {
-    label: 'forrange',
-    kind: 'Snippet',
-    insertText: 'for ${1:i} in range(${2:10}):\n    ${3:pass}',
-    detail: 'for range循环',
-    documentation: 'for range循环'
-  },
-  {
-    label: 'forenumerate',
-    kind: 'Snippet',
-    insertText: 'for ${1:index}, ${2:item} in enumerate(${3:iterable}):\n    ${4:pass}',
-    detail: 'for enumerate循环',
-    documentation: 'for enumerate循环，同时获取索引和值'
-  },
-  {
-    label: 'while',
-    kind: 'Snippet',
-    insertText: 'while ${1:condition}:\n    ${2:pass}',
-    detail: 'while循环',
-    documentation: 'while循环语句'
-  },
-  {
-    label: 'def',
-    kind: 'Snippet',
-    insertText: 'def ${1:function_name}(${2:args}):\n    """${3:docstring}"""\n    ${4:pass}',
-    detail: '函数定义',
-    documentation: '定义一个函数'
-  },
-  {
-    label: 'defret',
-    kind: 'Snippet',
-    insertText: 'def ${1:function_name}(${2:args}):\n    """${3:docstring}"""\n    ${4:pass}\n    return ${5:result}',
-    detail: '带返回值的函数',
-    documentation: '定义一个带返回值的函数'
-  },
-  {
-    label: 'class',
-    kind: 'Snippet',
-    insertText: 'class ${1:ClassName}:\n    """${2:docstring}"""\n    \n    def __init__(self${3:, args}):\n        ${4:pass}',
-    detail: '类定义',
-    documentation: '定义一个类'
-  },
-  {
-    label: 'classinit',
-    kind: 'Snippet',
-    insertText: 'def __init__(self${1:, args}):\n    ${2:pass}',
-    detail: '__init__方法',
-    documentation: '类的初始化方法'
-  },
-  {
-    label: 'try',
-    kind: 'Snippet',
-    insertText: 'try:\n    ${1:pass}\nexcept ${2:Exception} as ${3:e}:\n    ${4:pass}',
-    detail: 'try-except',
-    documentation: 'try-except异常处理'
-  },
-  {
-    label: 'tryfinally',
-    kind: 'Snippet',
-    insertText: 'try:\n    ${1:pass}\nexcept ${2:Exception} as ${3:e}:\n    ${4:pass}\nfinally:\n    ${5:pass}',
-    detail: 'try-except-finally',
-    documentation: 'try-except-finally完整异常处理'
-  },
-  {
-    label: 'with',
-    kind: 'Snippet',
-    insertText: 'with ${1:expression} as ${2:variable}:\n    ${3:pass}',
-    detail: 'with语句',
-    documentation: 'with上下文管理器'
-  },
-  {
-    label: 'withopen',
-    kind: 'Snippet',
-    insertText: 'with open(${1:\'filename\'}, ${2:\'r\'}) as ${3:f}:\n    ${4:content = f.read()}',
-    detail: 'with open文件操作',
-    documentation: '使用with打开文件'
-  },
-  {
-    label: 'lambda',
-    kind: 'Snippet',
-    insertText: 'lambda ${1:x}: ${2:x * 2}',
-    detail: 'lambda表达式',
-    documentation: 'lambda匿名函数'
-  },
-  {
-    label: 'listcomp',
-    kind: 'Snippet',
-    insertText: '[${1:x} for ${2:x} in ${3:iterable}]',
-    detail: '列表推导式',
-    documentation: '列表推导式'
-  },
-  {
-    label: 'dictcomp',
-    kind: 'Snippet',
-    insertText: '{${1:k}: ${2:v} for ${3:k}, ${4:v} in ${5:iterable}}',
-    detail: '字典推导式',
-    documentation: '字典推导式'
-  },
-  {
-    label: 'setcomp',
-    kind: 'Snippet',
-    insertText: '{${1:x} for ${2:x} in ${3:iterable}}',
-    detail: '集合推导式',
-    documentation: '集合推导式'
-  },
-  {
-    label: 'ifmain',
-    kind: 'Snippet',
-    insertText: 'if __name__ == \'__main__\':\n    ${1:main()}',
-    detail: 'if __name__ == __main__',
-    documentation: '主程序入口'
-  },
-  {
-    label: 'import',
-    kind: 'Snippet',
-    insertText: 'import ${1:module}',
-    detail: 'import语句',
-    documentation: '导入模块'
-  },
-  {
-    label: 'from',
-    kind: 'Snippet',
-    insertText: 'from ${1:module} import ${2:name}',
-    detail: 'from import语句',
-    documentation: '从模块导入'
-  },
-  {
-    label: 'async def',
-    kind: 'Snippet',
-    insertText: 'async def ${1:function_name}(${2:args}):\n    """${3:docstring}"""\n    ${4:pass}',
-    detail: '异步函数定义',
-    documentation: '定义一个异步函数'
-  },
-  {
-    label: 'await',
-    kind: 'Snippet',
-    insertText: 'await ${1:coroutine}',
-    detail: 'await表达式',
-    documentation: '等待异步操作完成'
-  },
-  {
-    label: 'property',
-    kind: 'Snippet',
-    insertText: '@property\ndef ${1:name}(self):\n    """${2:docstring}"""\n    return self._${1:name}',
-    detail: '@property装饰器',
-    documentation: '属性装饰器'
-  },
-  {
-    label: 'setter',
-    kind: 'Snippet',
-    insertText: '@${1:name}.setter\ndef ${1:name}(self, value):\n    self._${1:name} = value',
-    detail: '@setter装饰器',
-    documentation: '属性setter装饰器'
-  },
-  {
-    label: 'staticmethod',
-    kind: 'Snippet',
-    insertText: '@staticmethod\ndef ${1:method_name}(${2:args}):\n    """${3:docstring}"""\n    ${4:pass}',
-    detail: '@staticmethod装饰器',
-    documentation: '静态方法装饰器'
-  },
-  {
-    label: 'classmethod',
-    kind: 'Snippet',
-    insertText: '@classmethod\ndef ${1:method_name}(cls${2:, args}):\n    """${3:docstring}"""\n    ${4:pass}',
-    detail: '@classmethod装饰器',
-    documentation: '类方法装饰器'
-  },
-  {
-    label: 'docstring',
-    kind: 'Snippet',
-    insertText: '"""\n${1:描述}\n\nArgs:\n    ${2:参数}: ${3:说明}\n\nReturns:\n    ${4:返回值说明}\n"""',
-    detail: '函数文档字符串',
-    documentation: 'Google风格的文档字符串'
-  },
-  {
-    label: 'main',
-    kind: 'Snippet',
-    insertText: 'def main():\n    """主函数"""\n    ${1:pass}\n\n\nif __name__ == \'__main__\':\n    main()',
-    detail: '主函数模板',
-    documentation: '完整的主函数模板'
-  }
-];
-
-/**
- * 注册Python补全提供器
- * @param {Object} monaco Monaco编辑器实例
- */
-export function registerPythonCompletionProvider(monaco) {
-  if (!monaco || !monaco.languages) {
-    console.warn('Monaco未初始化，无法注册Python补全');
-    return null;
-  }
-
-  // 注册补全提供器
-  const provider = monaco.languages.registerCompletionItemProvider('python', {
-    triggerCharacters: ['.', ' '],
-    
-    provideCompletionItems: (model, position) => {
-      const word = model.getWordUntilPosition(position);
-      const range = {
-        startLineNumber: position.lineNumber,
-        endLineNumber: position.lineNumber,
-        startColumn: word.startColumn,
-        endColumn: word.endColumn
-      };
-
-      const suggestions = [];
-
-      // 添加关键字补全
-      PYTHON_KEYWORDS.forEach(keyword => {
-        suggestions.push({
-          label: keyword,
-          kind: monaco.languages.CompletionItemKind.Keyword,
-          insertText: keyword,
-          range: range,
-          detail: 'Python关键字',
-          sortText: '1' + keyword // 关键字优先级较高
-        });
-      });
-
-      // 添加内置函数补全
-      PYTHON_BUILTINS.forEach(builtin => {
-        suggestions.push({
-          label: builtin,
-          kind: monaco.languages.CompletionItemKind.Function,
-          insertText: builtin + '($0)',
-          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-          range: range,
-          detail: 'Python内置函数',
-          sortText: '2' + builtin
-        });
-      });
-
-      // 添加代码片段
-      PYTHON_SNIPPETS.forEach(snippet => {
-        const kind = snippet.kind === 'Snippet' 
-          ? monaco.languages.CompletionItemKind.Snippet
-          : monaco.languages.CompletionItemKind.Text;
-        
-        suggestions.push({
-          label: snippet.label,
-          kind: kind,
-          insertText: snippet.insertText,
-          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-          range: range,
-          detail: snippet.detail,
-          documentation: snippet.documentation,
-          sortText: '0' + snippet.label // 代码片段优先级最高
-        });
-      });
-
-      return { suggestions };
-    }
-  });
-
-  console.log('✅ Python补全提供器已注册');
-  return provider;
-}
-
-/**
- * 注销补全提供器
- * @param {Object} provider 提供器实例
- */
-export function disposePythonCompletionProvider(provider) {
-  if (provider && provider.dispose) {
-    provider.dispose();
-    console.log('Python补全提供器已注销');
-  }
-}
-
-export default {
-  registerPythonCompletionProvider,
-  disposePythonCompletionProvider,
-  PYTHON_KEYWORDS,
-  PYTHON_BUILTINS,
-  PYTHON_SNIPPETS
-};

web-front/src/views/Home.vue

@@ -48,7 +48,7 @@
         </div>
         <!-- 项目简介移到卡片内 -->
         <div class="project-intro">
-          <div class="intro-title">NFD网盘直链解析0.1.9b19p</div>
+          <div class="intro-title">NFD网盘直链解析0.1.9_b15</div>
           <div class="intro-desc">
             <div>支持网盘：蓝奏云、蓝奏云优享、小飞机盘、123云盘、奶牛快传、移动云空间、QQ邮箱云盘、QQ闪传等 <el-link style="color:#606cf5" href="https://github.com/qaiu/netdisk-fast-download?tab=readme-ov-file#%E7%BD%91%E7%9B%98%E6%94%AF%E6%8C%81%E6%83%85%E5%86%B5" target="_blank"> &gt;&gt; </el-link></div>
             <div>文件夹解析支持：蓝奏云、蓝奏云优享、小飞机盘、123云盘</div>
@@ -400,7 +400,7 @@ export default {
         const data = result.data
         
         // 检查是否支持目录解析
-        const supportedPans = ["iz", "lz", "fj", "ye"]
+        const supportedPans = ["iz", "lz", "fj", "ye", "le"]
         if (!supportedPans.includes(data.shareLinkInfo.type)) {
           this.$message.error("当前网盘不支持目录解析")
           return

web-service/pom.xml

@@ -160,22 +160,6 @@
                             <outputDirectory>${packageDirectory}/resources</outputDirectory>
                         </configuration>
                     </execution>
-                    <!-- 复制 graalpy-packages 到 resources 目录 (从 parser 模块) -->
-                    <execution>
-                        <id>copy-graalpy-packages</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>copy-resources</goal>
-                        </goals>
-                        <configuration>
-                            <resources>
-                                <resource>
-                                    <directory>${project.parent.basedir}/parser/src/main/resources/graalpy-packages</directory>
-                                </resource>
-                            </resources>
-                            <outputDirectory>${packageDirectory}/resources/graalpy-packages</outputDirectory>
-                        </configuration>
-                    </execution>
                 </executions>
             </plugin>
             <plugin>

web-service/src/main/java/cn/qaiu/lz/AppMain.java

@@ -63,9 +63,6 @@ public class AppMain {
                             System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS"));
                             System.out.println("数据库连接成功");
                             
-                            // 初始化示例解析器
-                            initExampleParsers();
-                            
                             // 加载演练场解析器
                             loadPlaygroundParsers();
                             
@@ -108,17 +105,6 @@ public class AppMain {
         PlaygroundConfig.loadFromJson(jsonObject);
     }
     
-    /**
-     * 初始化示例解析器（JS和Python）
-     */
-    private static void initExampleParsers() {
-        DbService dbService = AsyncServiceUtil.getAsyncServiceInstance(DbService.class);
-        
-        dbService.initExampleParsers()
-            .onSuccess(v -> log.info("示例解析器初始化检查完成"))
-            .onFailure(e -> log.error("示例解析器初始化失败", e));
-    }
-    
     /**
      * 在启动时加载所有已发布的演练场解析器
      */

web-service/src/main/java/cn/qaiu/lz/web/controller/PlaygroundApi.java

@@ -9,9 +9,6 @@ import cn.qaiu.parser.custom.CustomParserRegistry;
 import cn.qaiu.parser.customjs.JsPlaygroundExecutor;
 import cn.qaiu.parser.customjs.JsPlaygroundLogger;
 import cn.qaiu.parser.customjs.JsScriptMetadataParser;
-import cn.qaiu.parser.custompy.PyPlaygroundExecutor;
-import cn.qaiu.parser.custompy.PyPlaygroundLogger;
-import cn.qaiu.parser.custompy.PyScriptMetadataParser;
 import cn.qaiu.vx.core.annotaions.RouteHandler;
 import cn.qaiu.vx.core.annotaions.RouteMapping;
 import cn.qaiu.vx.core.enums.RouteMethod;
@@ -158,7 +155,7 @@ public class PlaygroundApi {
     }
 
     /**
-     * 测试执行JavaScript/Python代码
+     * 测试执行JavaScript代码
      *
      * @param ctx 路由上下文
      * @return 测试结果
@@ -179,38 +176,25 @@ public class PlaygroundApi {
 
         try {
             JsonObject body = ctx.body().asJsonObject();
-            String code = body.getString("jsCode"); // 兼容旧字段名
-            if (StringUtils.isBlank(code)) {
-                code = body.getString("code"); // 也支持新字段名
-            }
+            String jsCode = body.getString("jsCode");
             String shareUrl = body.getString("shareUrl");
             String pwd = body.getString("pwd");
             String method = body.getString("method", "parse");
-            String language = body.getString("language", "javascript").toLowerCase();
 
             // 参数验证
-            if (StringUtils.isBlank(code)) {
+            if (StringUtils.isBlank(jsCode)) {
                 promise.complete(JsonObject.mapFrom(PlaygroundTestResp.builder()
                         .success(false)
-                        .error("代码不能为空")
-                        .build()));
-                return promise.future();
-            }
-            
-            // 验证语言类型
-            if (!"javascript".equals(language) && !"python".equals(language)) {
-                promise.complete(JsonObject.mapFrom(PlaygroundTestResp.builder()
-                        .success(false)
-                        .error("不支持的语言类型: " + language + "，仅支持 javascript 或 python")
+                        .error("JavaScript代码不能为空")
                         .build()));
                 return promise.future();
             }
             
             // 代码长度验证
-            if (code.length() > MAX_CODE_LENGTH) {
+            if (jsCode.length() > MAX_CODE_LENGTH) {
                 promise.complete(JsonObject.mapFrom(PlaygroundTestResp.builder()
                         .success(false)
-                        .error("代码长度超过限制（最大128KB），当前长度: " + code.length() + " 字节")
+                        .error("代码长度超过限制（最大128KB），当前长度: " + jsCode.length() + " 字节")
                         .build()));
                 return promise.future();
             }
@@ -223,16 +207,10 @@ public class PlaygroundApi {
                 return promise.future();
             }
             
-            // ===== 验证URL匹配（根据语言类型选择解析器） =====
+            // ===== 新增：验证URL匹配 =====
             try {
-                Pattern matchPattern;
-                if ("python".equals(language)) {
-                    var config = PyScriptMetadataParser.parseScript(code);
-                    matchPattern = config.getMatchPattern();
-                } else {
-                    var config = JsScriptMetadataParser.parseScript(code);
-                    matchPattern = config.getMatchPattern();
-                }
+                var config = JsScriptMetadataParser.parseScript(jsCode);
+                Pattern matchPattern = config.getMatchPattern();
                 
                 if (matchPattern != null) {
                     Matcher matcher = matchPattern.matcher(shareUrl);
@@ -263,15 +241,115 @@ public class PlaygroundApi {
                         .build()));
                 return promise.future();
             }
-            
-            // 根据语言类型执行代码
-            final String finalCode = code;
-            if ("python".equals(language)) {
-                executePythonTest(promise, finalCode, shareUrl, pwd, method);
-            } else {
-                executeJavaScriptTest(promise, finalCode, shareUrl, pwd, method);
-            }
 
+            long startTime = System.currentTimeMillis();
+
+            try {
+                // 创建ShareLinkInfo
+                ParserCreate parserCreate = ParserCreate.fromShareUrl(shareUrl);
+                if (StringUtils.isNotBlank(pwd)) {
+                    parserCreate.setShareLinkInfoPwd(pwd);
+                }
+                ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
+
+                // 创建演练场执行器
+                JsPlaygroundExecutor executor = new JsPlaygroundExecutor(shareLinkInfo, jsCode);
+
+                // 根据方法类型选择执行，并异步处理结果
+                Future<Object> executionFuture;
+                switch (method) {
+                    case "parse":
+                        executionFuture = executor.executeParseAsync().map(r -> (Object) r);
+                        break;
+                    case "parseFileList":
+                        executionFuture = executor.executeParseFileListAsync().map(r -> (Object) r);
+                        break;
+                    case "parseById":
+                        executionFuture = executor.executeParseByIdAsync().map(r -> (Object) r);
+                        break;
+                    default:
+                        promise.fail(new IllegalArgumentException("未知的方法类型: " + method));
+                        return promise.future();
+                }
+
+                // 异步处理执行结果
+                executionFuture.onSuccess(result -> {
+                    log.debug("执行成功，结果类型: {}, 结果值: {}", 
+                            result != null ? result.getClass().getSimpleName() : "null", 
+                            result);
+                    
+                    // 获取日志
+                    List<JsPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
+                    log.debug("获取到 {} 条日志记录", logEntries.size());
+                    
+                    List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
+                            .map(entry -> PlaygroundTestResp.LogEntry.builder()
+                                    .level(entry.getLevel())
+                                    .message(entry.getMessage())
+                                    .timestamp(entry.getTimestamp())
+                                    .source(entry.getSource())  // 使用日志条目的来源标识
+                                    .build())
+                            .collect(Collectors.toList());
+
+                    long executionTime = System.currentTimeMillis() - startTime;
+
+                    // 构建响应
+                    PlaygroundTestResp response = PlaygroundTestResp.builder()
+                            .success(true)
+                            .result(result)
+                            .logs(respLogs)
+                            .executionTime(executionTime)
+                            .build();
+
+                    JsonObject jsonResponse = JsonObject.mapFrom(response);
+                    log.debug("测试成功响应: {}", jsonResponse.encodePrettily());
+                    promise.complete(jsonResponse);
+                }).onFailure(e -> {
+                    long executionTime = System.currentTimeMillis() - startTime;
+                    String errorMessage = e.getMessage();
+                    String stackTrace = getStackTrace(e);
+
+                    log.error("演练场执行失败", e);
+
+                    // 尝试获取已有的日志
+                    List<JsPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
+                    List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
+                            .map(entry -> PlaygroundTestResp.LogEntry.builder()
+                                    .level(entry.getLevel())
+                                    .message(entry.getMessage())
+                                    .timestamp(entry.getTimestamp())
+                                    .source(entry.getSource())  // 使用日志条目的来源标识
+                                    .build())
+                            .collect(Collectors.toList());
+
+                    PlaygroundTestResp response = PlaygroundTestResp.builder()
+                            .success(false)
+                            .error(errorMessage)
+                            .stackTrace(stackTrace)
+                            .executionTime(executionTime)
+                            .logs(respLogs)
+                            .build();
+
+                    promise.complete(JsonObject.mapFrom(response));
+                });
+
+            } catch (Exception e) {
+                long executionTime = System.currentTimeMillis() - startTime;
+                String errorMessage = e.getMessage();
+                String stackTrace = getStackTrace(e);
+
+                log.error("演练场初始化失败", e);
+
+                PlaygroundTestResp response = PlaygroundTestResp.builder()
+                        .success(false)
+                        .error(errorMessage)
+                        .stackTrace(stackTrace)
+                        .executionTime(executionTime)
+                        .logs(new ArrayList<>())
+                        .build();
+
+                promise.complete(JsonObject.mapFrom(response));
+            }
         } catch (Exception e) {
             log.error("解析请求参数失败", e);
             promise.complete(JsonObject.mapFrom(PlaygroundTestResp.builder()
@@ -283,230 +361,6 @@ public class PlaygroundApi {
 
         return promise.future();
     }
-    
-    /**
-     * 执行JavaScript测试
-     */
-    private void executeJavaScriptTest(Promise<JsonObject> promise, String jsCode, String shareUrl, String pwd, String method) {
-        long startTime = System.currentTimeMillis();
-
-        try {
-            // 创建ShareLinkInfo
-            ParserCreate parserCreate = ParserCreate.fromShareUrl(shareUrl);
-            if (StringUtils.isNotBlank(pwd)) {
-                parserCreate.setShareLinkInfoPwd(pwd);
-            }
-            ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-
-            // 创建演练场执行器
-            JsPlaygroundExecutor executor = new JsPlaygroundExecutor(shareLinkInfo, jsCode);
-
-            // 根据方法类型选择执行，并异步处理结果
-            Future<Object> executionFuture;
-            switch (method) {
-                case "parse":
-                    executionFuture = executor.executeParseAsync().map(r -> (Object) r);
-                    break;
-                case "parseFileList":
-                    executionFuture = executor.executeParseFileListAsync().map(r -> (Object) r);
-                    break;
-                case "parseById":
-                    executionFuture = executor.executeParseByIdAsync().map(r -> (Object) r);
-                    break;
-                default:
-                    promise.fail(new IllegalArgumentException("未知的方法类型: " + method));
-                    return;
-            }
-
-            // 异步处理执行结果
-            executionFuture.onSuccess(result -> {
-                log.debug("JavaScript执行成功，结果类型: {}, 结果值: {}", 
-                        result != null ? result.getClass().getSimpleName() : "null", 
-                        result);
-                
-                // 获取日志
-                List<JsPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
-                log.debug("获取到 {} 条日志记录", logEntries.size());
-                
-                List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
-                        .map(entry -> PlaygroundTestResp.LogEntry.builder()
-                                .level(entry.getLevel())
-                                .message(entry.getMessage())
-                                .timestamp(entry.getTimestamp())
-                                .source(entry.getSource())
-                                .build())
-                        .collect(Collectors.toList());
-
-                long executionTime = System.currentTimeMillis() - startTime;
-
-                PlaygroundTestResp response = PlaygroundTestResp.builder()
-                        .success(true)
-                        .result(result)
-                        .logs(respLogs)
-                        .executionTime(executionTime)
-                        .build();
-
-                JsonObject jsonResponse = JsonObject.mapFrom(response);
-                log.debug("JavaScript测试成功响应: {}", jsonResponse.encodePrettily());
-                promise.complete(jsonResponse);
-            }).onFailure(e -> {
-                long executionTime = System.currentTimeMillis() - startTime;
-                String errorMessage = e.getMessage();
-                String stackTrace = getStackTrace(e);
-
-                log.error("JavaScript演练场执行失败", e);
-
-                List<JsPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
-                List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
-                        .map(entry -> PlaygroundTestResp.LogEntry.builder()
-                                .level(entry.getLevel())
-                                .message(entry.getMessage())
-                                .timestamp(entry.getTimestamp())
-                                .source(entry.getSource())
-                                .build())
-                        .collect(Collectors.toList());
-
-                PlaygroundTestResp response = PlaygroundTestResp.builder()
-                        .success(false)
-                        .error(errorMessage)
-                        .stackTrace(stackTrace)
-                        .executionTime(executionTime)
-                        .logs(respLogs)
-                        .build();
-
-                promise.complete(JsonObject.mapFrom(response));
-            });
-
-        } catch (Exception e) {
-            long executionTime = System.currentTimeMillis() - startTime;
-            String errorMessage = e.getMessage();
-            String stackTrace = getStackTrace(e);
-
-            log.error("JavaScript演练场初始化失败", e);
-
-            PlaygroundTestResp response = PlaygroundTestResp.builder()
-                    .success(false)
-                    .error(errorMessage)
-                    .stackTrace(stackTrace)
-                    .executionTime(executionTime)
-                    .logs(new ArrayList<>())
-                    .build();
-
-            promise.complete(JsonObject.mapFrom(response));
-        }
-    }
-    
-    /**
-     * 执行Python测试
-     */
-    private void executePythonTest(Promise<JsonObject> promise, String pyCode, String shareUrl, String pwd, String method) {
-        long startTime = System.currentTimeMillis();
-
-        try {
-            // 创建ShareLinkInfo
-            ParserCreate parserCreate = ParserCreate.fromShareUrl(shareUrl);
-            if (StringUtils.isNotBlank(pwd)) {
-                parserCreate.setShareLinkInfoPwd(pwd);
-            }
-            ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-
-            // 创建Python演练场执行器
-            PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-
-            // 根据方法类型选择执行，并异步处理结果
-            Future<Object> executionFuture;
-            switch (method) {
-                case "parse":
-                    executionFuture = executor.executeParseAsync().map(r -> (Object) r);
-                    break;
-                case "parseFileList":
-                    executionFuture = executor.executeParseFileListAsync().map(r -> (Object) r);
-                    break;
-                case "parseById":
-                    executionFuture = executor.executeParseByIdAsync().map(r -> (Object) r);
-                    break;
-                default:
-                    promise.fail(new IllegalArgumentException("未知的方法类型: " + method));
-                    return;
-            }
-
-            // 异步处理执行结果
-            executionFuture.onSuccess(result -> {
-                log.debug("Python执行成功，结果类型: {}, 结果值: {}", 
-                        result != null ? result.getClass().getSimpleName() : "null", 
-                        result);
-                
-                // 获取日志
-                List<PyPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
-                log.debug("获取到 {} 条日志记录", logEntries.size());
-                
-                List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
-                        .map(entry -> PlaygroundTestResp.LogEntry.builder()
-                                .level(entry.getLevel())
-                                .message(entry.getMessage())
-                                .timestamp(entry.getTimestamp())
-                                .source(entry.getSource())
-                                .build())
-                        .collect(Collectors.toList());
-
-                long executionTime = System.currentTimeMillis() - startTime;
-
-                PlaygroundTestResp response = PlaygroundTestResp.builder()
-                        .success(true)
-                        .result(result)
-                        .logs(respLogs)
-                        .executionTime(executionTime)
-                        .build();
-
-                JsonObject jsonResponse = JsonObject.mapFrom(response);
-                log.debug("Python测试成功响应: {}", jsonResponse.encodePrettily());
-                promise.complete(jsonResponse);
-            }).onFailure(e -> {
-                long executionTime = System.currentTimeMillis() - startTime;
-                String errorMessage = e.getMessage();
-                String stackTrace = getStackTrace(e);
-
-                log.error("Python演练场执行失败", e);
-
-                List<PyPlaygroundLogger.LogEntry> logEntries = executor.getLogs();
-                List<PlaygroundTestResp.LogEntry> respLogs = logEntries.stream()
-                        .map(entry -> PlaygroundTestResp.LogEntry.builder()
-                                .level(entry.getLevel())
-                                .message(entry.getMessage())
-                                .timestamp(entry.getTimestamp())
-                                .source(entry.getSource())
-                                .build())
-                        .collect(Collectors.toList());
-
-                PlaygroundTestResp response = PlaygroundTestResp.builder()
-                        .success(false)
-                        .error(errorMessage)
-                        .stackTrace(stackTrace)
-                        .executionTime(executionTime)
-                        .logs(respLogs)
-                        .build();
-
-                promise.complete(JsonObject.mapFrom(response));
-            });
-
-        } catch (Exception e) {
-            long executionTime = System.currentTimeMillis() - startTime;
-            String errorMessage = e.getMessage();
-            String stackTrace = getStackTrace(e);
-
-            log.error("Python演练场初始化失败", e);
-
-            PlaygroundTestResp response = PlaygroundTestResp.builder()
-                    .success(false)
-                    .error(errorMessage)
-                    .stackTrace(stackTrace)
-                    .executionTime(executionTime)
-                    .logs(new ArrayList<>())
-                    .build();
-
-            promise.complete(JsonObject.mapFrom(response));
-        }
-    }
 
     /**
      * 获取types.js文件内容
@@ -548,47 +402,6 @@ public class PlaygroundApi {
             ResponseUtil.fireJsonResultResponse(response, JsonResult.error("读取types.js失败: " + e.getMessage()));
         }
     }
-    
-    /**
-     * 获取types.pyi文件内容（Python类型提示）
-     *
-     * @param ctx 路由上下文
-     * @param response HTTP响应
-     */
-    @RouteMapping(value = "/types.pyi", method = RouteMethod.GET)
-    public void getTypesPyi(RoutingContext ctx, HttpServerResponse response) {
-        // 检查是否启用
-        if (!checkEnabled()) {
-            ResponseUtil.fireJsonResultResponse(response, JsonResult.error("演练场功能已禁用"));
-            return;
-        }
-        
-        // 权限检查
-        if (!checkAuth(ctx)) {
-            ResponseUtil.fireJsonResultResponse(response, JsonResult.error("未授权访问"));
-            return;
-        }
-        
-        try (InputStream inputStream = getClass().getClassLoader()
-                .getResourceAsStream("py/types.pyi")) {
-
-            if (inputStream == null) {
-                ResponseUtil.fireJsonResultResponse(response, JsonResult.error("types.pyi文件不存在"));
-                return;
-            }
-
-            String content = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))
-                    .lines()
-                    .collect(Collectors.joining("\n"));
-
-            response.putHeader("Content-Type", "text/x-python; charset=utf-8")
-                    .end(content);
-
-        } catch (Exception e) {
-            log.error("读取types.pyi失败", e);
-            ResponseUtil.fireJsonResultResponse(response, JsonResult.error("读取types.pyi失败: " + e.getMessage()));
-        }
-    }
 
     /**
      * 获取解析器列表
@@ -626,39 +439,22 @@ public class PlaygroundApi {
 
         try {
             JsonObject body = ctx.body().asJsonObject();
-            String code = body.getString("jsCode"); // 兼容旧字段名
-            if (StringUtils.isBlank(code)) {
-                code = body.getString("code"); // 也支持新字段名
-            }
-            String language = body.getString("language", "javascript").toLowerCase();
+            String jsCode = body.getString("jsCode");
 
-            if (StringUtils.isBlank(code)) {
-                promise.complete(JsonResult.error("代码不能为空").toJsonObject());
-                return promise.future();
-            }
-            
-            // 验证语言类型
-            if (!"javascript".equals(language) && !"python".equals(language)) {
-                promise.complete(JsonResult.error("不支持的语言类型: " + language + "，仅支持 javascript 或 python").toJsonObject());
+            if (StringUtils.isBlank(jsCode)) {
+                promise.complete(JsonResult.error("JavaScript代码不能为空").toJsonObject());
                 return promise.future();
             }
             
             // 代码长度验证
-            if (code.length() > MAX_CODE_LENGTH) {
-                promise.complete(JsonResult.error("代码长度超过限制（最大128KB），当前长度: " + code.length() + " 字节").toJsonObject());
+            if (jsCode.length() > MAX_CODE_LENGTH) {
+                promise.complete(JsonResult.error("代码长度超过限制（最大128KB），当前长度: " + jsCode.length() + " 字节").toJsonObject());
                 return promise.future();
             }
 
-            // 根据语言类型解析元数据
-            final String finalCode = code;
+            // 解析元数据
             try {
-                cn.qaiu.parser.custom.CustomParserConfig config;
-                if ("python".equals(language)) {
-                    config = PyScriptMetadataParser.parseScript(finalCode);
-                } else {
-                    config = JsScriptMetadataParser.parseScript(finalCode);
-                }
-                
+                var config = JsScriptMetadataParser.parseScript(jsCode);
                 String type = config.getType();
                 String displayName = config.getDisplayName();
                 String name = config.getMetadata().get("name");
@@ -666,10 +462,6 @@ public class PlaygroundApi {
                 String author = config.getMetadata().get("author");
                 String version = config.getMetadata().get("version");
                 String matchPattern = config.getMatchPattern() != null ? config.getMatchPattern().pattern() : null;
-                final boolean isPython = "python".equals(language);
-                
-                // 在外部提取forceOverwrite参数，避免lambda中类型转换问题
-                final boolean forceOverwrite = Boolean.TRUE.equals(body.getValue("forceOverwrite"));
 
                 // 检查数量限制
                 dbService.getPlaygroundParserCount().onSuccess(count -> {
@@ -681,29 +473,23 @@ public class PlaygroundApi {
                     // 检查type是否已存在
                     dbService.getPlaygroundParserList().onSuccess(listResult -> {
                         var list = listResult.getJsonArray("data");
-                        Long existingId = null;
+                        boolean exists = false;
                         if (list != null) {
                             for (int i = 0; i < list.size(); i++) {
                                 var item = list.getJsonObject(i);
                                 if (type.equals(item.getString("type"))) {
-                                    existingId = item.getLong("id");
+                                    exists = true;
                                     break;
                                 }
                             }
                         }
 
-                        if (existingId != null && !forceOverwrite) {
-                            // type已存在且未强制覆盖，返回错误信息和existingId
-                            JsonObject errorResult = JsonResult.error("解析器类型 " + type + " 已存在，是否覆盖？").toJsonObject();
-                            errorResult.put("existingId", existingId);
-                            errorResult.put("existingType", type);
-                            promise.complete(errorResult);
+                        if (exists) {
+                            promise.complete(JsonResult.error("解析器类型 " + type + " 已存在，请使用其他类型标识").toJsonObject());
                             return;
                         }
-                        
-                        final Long finalExistingId = existingId;
 
-                        // 准备解析器数据
+                        // 保存到数据库
                         JsonObject parser = new JsonObject();
                         parser.put("name", name);
                         parser.put("type", type);
@@ -712,40 +498,16 @@ public class PlaygroundApi {
                         parser.put("author", author);
                         parser.put("version", version);
                         parser.put("matchPattern", matchPattern);
-                        parser.put("jsCode", finalCode); // 兼容旧字段名存储
-                        parser.put("language", isPython ? "python" : "javascript");
+                        parser.put("jsCode", jsCode);
                         parser.put("ip", getClientIp(ctx.request()));
                         parser.put("enabled", true);
 
-                        // 根据是否覆盖选择不同的操作
-                        Future<JsonObject> saveFuture;
-                        if (finalExistingId != null) {
-                            // 覆盖模式：更新现有解析器
-                            saveFuture = dbService.updatePlaygroundParser(finalExistingId, parser);
-                            log.info("覆盖现有解析器，ID: {}, type: {}", finalExistingId, type);
-                        } else {
-                            // 新增模式
-                            saveFuture = dbService.savePlaygroundParser(parser);
-                        }
-                        
-                        saveFuture.onSuccess(result -> {
-                            // 保存成功后，注册/重新注册到解析器系统
+                        dbService.savePlaygroundParser(parser).onSuccess(result -> {
+                            // 保存成功后，立即注册到解析器系统
                             try {
-                                // 先注销旧的（覆盖模式需要）
-                                if (finalExistingId != null) {
-                                    CustomParserRegistry.unregister(type);
-                                }
-                                
-                                // 注册新的
-                                if (isPython) {
-                                    CustomParserRegistry.registerPy(config);
-                                } else {
-                                    CustomParserRegistry.register(config);
-                                }
-                                
-                                String action = finalExistingId != null ? "覆盖并重新注册" : "保存并注册";
-                                log.info("{}演练场{}解析器: {} ({})", action, isPython ? "Python" : "JavaScript", displayName, type);
-                                promise.complete(JsonResult.success(action + "成功").toJsonObject());
+                                CustomParserRegistry.register(config);
+                                log.info("已注册演练场解析器: {} ({})", displayName, type);
+                                promise.complete(JsonResult.success("保存并注册成功").toJsonObject());
                             } catch (Exception e) {
                                 log.error("注册解析器失败", e);
                                 // 虽然注册失败，但保存成功了，返回警告
@@ -797,33 +559,16 @@ public class PlaygroundApi {
 
         try {
             JsonObject body = ctx.body().asJsonObject();
-            String code = body.getString("jsCode"); // 兼容旧字段名
-            if (StringUtils.isBlank(code)) {
-                code = body.getString("code"); // 也支持新字段名
-            }
-            String language = body.getString("language", "javascript").toLowerCase();
+            String jsCode = body.getString("jsCode");
 
-            if (StringUtils.isBlank(code)) {
-                promise.complete(JsonResult.error("代码不能为空").toJsonObject());
-                return promise.future();
-            }
-            
-            // 验证语言类型
-            if (!"javascript".equals(language) && !"python".equals(language)) {
-                promise.complete(JsonResult.error("不支持的语言类型: " + language + "，仅支持 javascript 或 python").toJsonObject());
+            if (StringUtils.isBlank(jsCode)) {
+                promise.complete(JsonResult.error("JavaScript代码不能为空").toJsonObject());
                 return promise.future();
             }
 
-            // 根据语言类型解析元数据
-            final String finalCode = code;
+            // 解析元数据
             try {
-                cn.qaiu.parser.custom.CustomParserConfig config;
-                if ("python".equals(language)) {
-                    config = PyScriptMetadataParser.parseScript(finalCode);
-                } else {
-                    config = JsScriptMetadataParser.parseScript(finalCode);
-                }
-                
+                var config = JsScriptMetadataParser.parseScript(jsCode);
                 String type = config.getType();
                 String displayName = config.getDisplayName();
                 String name = config.getMetadata().get("name");
@@ -832,7 +577,6 @@ public class PlaygroundApi {
                 String version = config.getMetadata().get("version");
                 String matchPattern = config.getMatchPattern() != null ? config.getMatchPattern().pattern() : null;
                 boolean enabled = body.getBoolean("enabled", true);
-                final boolean isPython = "python".equals(language);
 
                 JsonObject parser = new JsonObject();
                 parser.put("name", name);
@@ -841,8 +585,7 @@ public class PlaygroundApi {
                 parser.put("author", author);
                 parser.put("version", version);
                 parser.put("matchPattern", matchPattern);
-                parser.put("jsCode", finalCode); // 兼容旧字段名存储
-                parser.put("language", isPython ? "python" : "javascript");
+                parser.put("jsCode", jsCode);
                 parser.put("enabled", enabled);
 
                 dbService.updatePlaygroundParser(id, parser).onSuccess(result -> {
@@ -852,12 +595,8 @@ public class PlaygroundApi {
                             // 先注销旧的（如果存在）
                             CustomParserRegistry.unregister(type);
                             // 重新注册新的
-                            if (isPython) {
-                                CustomParserRegistry.registerPy(config);
-                            } else {
-                                CustomParserRegistry.register(config);
-                            }
-                            log.info("已重新注册演练场{}解析器: {} ({})", isPython ? "Python" : "JavaScript", displayName, type);
+                            CustomParserRegistry.register(config);
+                            log.info("已重新注册演练场解析器: {} ({})", displayName, type);
                         } else {
                             // 禁用时注销
                             CustomParserRegistry.unregister(type);
@@ -952,64 +691,6 @@ public class PlaygroundApi {
         return dbService.getPlaygroundParserById(id);
     }
 
-    /**
-     * 获取示例解析器代码
-     * @param language 语言类型 (javascript 或 python)
-     */
-    @RouteMapping(value = "/example/:language", method = RouteMethod.GET)
-    public void getExampleParser(HttpServerResponse response, String language) {
-        // 权限检查（示例代码也需要认证）
-        if (!checkEnabled()) {
-            ResponseUtil.fireJsonObjectResponse(response, 
-                JsonResult.error("演练场功能已禁用").toJsonObject());
-            return;
-        }
-        
-        try {
-            String resourcePath;
-            String contentType = "text/plain; charset=utf-8";
-            
-            if ("python".equalsIgnoreCase(language)) {
-                resourcePath = "custom-parsers/py/example_parser.py";
-            } else if ("javascript".equalsIgnoreCase(language)) {
-                resourcePath = "custom-parsers/example-demo.js";
-            } else {
-                ResponseUtil.fireJsonObjectResponse(response, 
-                    JsonResult.error("不支持的语言类型: " + language).toJsonObject());
-                return;
-            }
-            
-            // 从资源文件加载示例代码
-            InputStream inputStream = getClass().getClassLoader().getResourceAsStream(resourcePath);
-            if (inputStream == null) {
-                log.error("无法找到示例文件: {}", resourcePath);
-                ResponseUtil.fireJsonObjectResponse(response, 
-                    JsonResult.error("示例文件不存在").toJsonObject());
-                return;
-            }
-            
-            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");
-                }
-            }
-            
-            // 返回示例代码
-            response.putHeader("Content-Type", contentType);
-            response.end(content.toString());
-            
-            log.debug("返回{}示例代码，长度: {} 字节", language, content.length());
-            
-        } catch (Exception e) {
-            log.error("加载示例文件失败", e);
-            ResponseUtil.fireJsonObjectResponse(response, 
-                JsonResult.error("加载示例失败: " + e.getMessage()).toJsonObject());
-        }
-    }
-
     /**
      * 获取客户端IP
      */

web-service/src/main/java/cn/qaiu/lz/web/controller/PylspWebSocketHandler.java

@@ -1,364 +0,0 @@
-package cn.qaiu.lz.web.controller;
-
-import cn.qaiu.lz.web.config.PlaygroundConfig;
-import cn.qaiu.vx.core.annotaions.RouteHandler;
-import cn.qaiu.vx.core.annotaions.SockRouteMapper;
-import io.vertx.core.buffer.Buffer;
-import io.vertx.ext.web.handler.sockjs.SockJSSocket;
-import lombok.extern.slf4j.Slf4j;
-
-import java.io.*;
-import java.nio.charset.StandardCharsets;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Python LSP (pylsp/jedi) WebSocket 桥接处理器
- * 
- * 通过 WebSocket 将前端 LSP 请求转发到 pylsp 子进程，
- * 实现实时代码检查、自动完成、悬停提示等功能。
- * 
- * 使用 jedi 的 python-lsp-server (pylsp)，需要预先安装:
- * pip install python-lsp-server[all]
- * 
- * @author <a href="https://qaiu.top">QAIU</a>
- */
-@RouteHandler(value = "/v2/ws")
-@Slf4j
-public class PylspWebSocketHandler {
-
-    // 存储每个 WebSocket 连接对应的 pylsp 进程
-    private static final ConcurrentHashMap<String, PylspSession> sessions = new ConcurrentHashMap<>();
-
-    /**
-     * WebSocket LSP 端点
-     * 前端通过此端点连接，发送 LSP JSON-RPC 消息
-     */
-    @SockRouteMapper("/pylsp")
-    public void handlePylsp(SockJSSocket socket) {
-        String sessionId = socket.writeHandlerID();
-        log.info("========================================");
-        log.info("[PYLSP] WebSocket Handler 被调用!");
-        log.info("[PYLSP] Session ID: {}", sessionId);
-        log.info("[PYLSP] Remote Address: {}", socket.remoteAddress());
-        log.info("========================================");
-
-        // 检查 Playground 是否启用
-        PlaygroundConfig config = PlaygroundConfig.getInstance();
-        log.info("[PYLSP] Playground enabled: {}", config.isEnabled());
-        log.info("[PYLSP] Playground public: {}", config.isPublic());
-        
-        if (!config.isEnabled()) {
-            log.error("[PYLSP] Playground功能已禁用! 请检查配置文件中 playground.enabled 设置");
-            log.error("[PYLSP] 当前配置: enabled={}, public={}", config.isEnabled(), config.isPublic());
-            socket.write(Buffer.buffer("{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32603,\"message\":\"Playground功能已禁用，请联系管理员\"},\"id\":null}"));
-            socket.close();
-            return;
-        }
-
-        // 创建 pylsp 会话
-        PylspSession session = new PylspSession(socket, sessionId);
-        sessions.put(sessionId, session);
-
-        // 启动 pylsp 进程
-        if (!session.start()) {
-            socket.write(Buffer.buffer("{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32603,\"message\":\"无法启动pylsp服务\"},\"id\":null}"));
-            socket.close();
-            sessions.remove(sessionId);
-            return;
-        }
-
-        // 处理来自前端的消息
-        socket.handler(buffer -> {
-            String message = buffer.toString(StandardCharsets.UTF_8);
-            log.debug("收到 LSP 请求: {}", message);
-            session.sendToLsp(message);
-        });
-
-        // 处理连接关闭
-        socket.endHandler(v -> {
-            log.info("pylsp WebSocket 连接关闭: {}", sessionId);
-            session.stop();
-            sessions.remove(sessionId);
-        });
-
-        // 处理异常
-        socket.exceptionHandler(e -> {
-            log.error("pylsp WebSocket 异常: {}", sessionId, e);
-            session.stop();
-            sessions.remove(sessionId);
-        });
-    }
-
-    /**
-     * 查找 graalpy-packages 目录路径
-     * 支持多种运行环境：开发环境、IDE 运行、jar 包运行
-     */
-    private static String findGraalPyPackagesPath(String userDir) {
-        // 按优先级尝试多个可能的路径
-        String[] possiblePaths = {
-            // 开发环境 - IDE 直接运行
-            userDir + "/parser/src/main/resources/graalpy-packages",
-            // Maven 编译后路径
-            userDir + "/parser/target/classes/graalpy-packages",
-            // jar 包同级目录
-            userDir + "/graalpy-packages",
-            // jar 包运行时的 resources 目录
-            userDir + "/resources/graalpy-packages",
-            // 相对于 web-service 模块
-            userDir + "/../parser/src/main/resources/graalpy-packages",
-            // 从 web-service/target/package 向上查找
-            userDir + "/../../parser/src/main/resources/graalpy-packages",
-            userDir + "/../../../parser/src/main/resources/graalpy-packages",
-        };
-        
-        for (String path : possiblePaths) {
-            File dir = new File(path);
-            if (dir.exists() && dir.isDirectory()) {
-                File pylspModule = new File(dir, "pylsp");
-                if (pylspModule.exists()) {
-                    try {
-                        String canonicalPath = dir.getCanonicalPath();
-                        log.info("[PYLSP] 找到 graalpy-packages: {}", canonicalPath);
-                        return canonicalPath;
-                    } catch (IOException e) {
-                        log.warn("[PYLSP] 获取规范路径失败: {}", path);
-                        return dir.getAbsolutePath();
-                    }
-                }
-            }
-        }
-        
-        // 打印尝试的所有路径用于调试
-        log.error("[PYLSP] 尝试的路径:");
-        for (String path : possiblePaths) {
-            File dir = new File(path);
-            log.error("[PYLSP]   {} (exists={})", path, dir.exists());
-        }
-        
-        return null;
-    }
-
-    /**
-     * pylsp 会话管理类
-     * 管理单个 pylsp 子进程和对应的 WebSocket 连接
-     */
-    private static class PylspSession {
-        private final SockJSSocket socket;
-        private final String sessionId;
-        private Process process;
-        private BufferedWriter processWriter;
-        private Thread readerThread;
-        private final AtomicBoolean running = new AtomicBoolean(false);
-
-        public PylspSession(SockJSSocket socket, String sessionId) {
-            this.socket = socket;
-            this.sessionId = sessionId;
-        }
-
-        /**
-         * 启动 pylsp 子进程
-         * 
-         * 使用 GraalPy 和打包在 jar 中的 python-lsp-server。
-         * graalpy-packages 中包含完整的 pylsp 依赖。
-         */
-        public boolean start() {
-            try {
-                // 检测运行环境（开发环境 vs jar 包）
-                String userDir = System.getProperty("user.dir");
-                String graalPyPackagesPath = findGraalPyPackagesPath(userDir);
-                
-                if (graalPyPackagesPath == null) {
-                    log.error("[PYLSP] 找不到 graalpy-packages 目录!");
-                    log.error("[PYLSP] 已尝试的路径: {}", userDir);
-                    log.error("[PYLSP] 请运行: parser/setup-graalpy-packages.sh");
-                    return false;
-                }
-                
-                // 检查 pylsp 是否存在
-                File pylspModule = new File(graalPyPackagesPath + "/pylsp");
-                if (!pylspModule.exists()) {
-                    log.error("[PYLSP] pylsp 模块不存在: {}", pylspModule.getAbsolutePath());
-                    log.error("[PYLSP] 请运行: parser/setup-graalpy-packages.sh");
-                    return false;
-                }
-                
-                // 使用系统 Python (因为 GraalPy 不支持作为独立进程运行 pylsp)
-                // 但通过 PYTHONPATH 使用打包的 pylsp
-                ProcessBuilder pb = new ProcessBuilder(
-                    "python3", "-m", "pylsp",
-                    "-v"      // 详细日志
-                );
-                
-                // 设置环境变量
-                var env = pb.environment();
-                env.put("PYTHONPATH", graalPyPackagesPath);
-                log.info("[PYLSP] PYTHONPATH: {}", graalPyPackagesPath);
-                
-                pb.redirectErrorStream(false);
-                process = pb.start();
-                
-                processWriter = new BufferedWriter(
-                    new OutputStreamWriter(process.getOutputStream(), StandardCharsets.UTF_8)
-                );
-
-                running.set(true);
-
-                // 启动读取线程，将 pylsp 的输出转发到 WebSocket
-                readerThread = new Thread(() -> readLspOutput(), "pylsp-reader-" + sessionId);
-                readerThread.setDaemon(true);
-                readerThread.start();
-
-                // 启动错误读取线程
-                Thread errorThread = new Thread(() -> readLspError(), "pylsp-error-" + sessionId);
-                errorThread.setDaemon(true);
-                errorThread.start();
-
-                log.info("[PYLSP] pylsp 进程已启动 (Session: {})", sessionId);
-                log.info("[PYLSP] 进程 PID: {}", process.pid());
-                return true;
-
-            } catch (Exception e) {
-                log.error("[PYLSP] 启动 pylsp 进程失败", e);
-                log.error("[PYLSP] 错误详情: {}", e.getMessage());
-                log.error("[PYLSP] 请确保:");
-                log.error("[PYLSP]   1. 已运行 parser/setup-graalpy-packages.sh");
-                log.error("[PYLSP]   2. 系统已安装 python3");
-                log.error("[PYLSP]   3. graalpy-packages 中包含 pylsp 模块");
-                return false;
-            }
-        }
-
-        /**
-         * 发送消息到 pylsp 进程
-         */
-        public void sendToLsp(String message) {
-            if (!running.get() || processWriter == null) {
-                return;
-            }
-
-            try {
-                // LSP 协议: Content-Length: xxx\r\n\r\n{json}
-                byte[] contentBytes = message.getBytes(StandardCharsets.UTF_8);
-                String header = "Content-Length: " + contentBytes.length + "\r\n\r\n";
-                
-                processWriter.write(header);
-                processWriter.write(message);
-                processWriter.flush();
-                
-                log.debug("发送到 pylsp: {}", message);
-            } catch (IOException e) {
-                log.error("发送消息到 pylsp 失败", e);
-            }
-        }
-
-        /**
-         * 读取 pylsp 输出并转发到 WebSocket
-         */
-        private void readLspOutput() {
-            try {
-                InputStream inputStream = process.getInputStream();
-                BufferedReader reader = new BufferedReader(
-                    new InputStreamReader(inputStream, StandardCharsets.UTF_8)
-                );
-
-                while (running.get()) {
-                    // 读取 LSP 头部
-                    String line = reader.readLine();
-                    if (line == null) {
-                        break;
-                    }
-
-                    // 解析 Content-Length
-                    int contentLength = -1;
-                    while (line != null && !line.isEmpty()) {
-                        if (line.startsWith("Content-Length:")) {
-                            contentLength = Integer.parseInt(line.substring(15).trim());
-                        }
-                        line = reader.readLine();
-                    }
-
-                    if (contentLength > 0) {
-                        // 读取 JSON 内容
-                        char[] content = new char[contentLength];
-                        int read = 0;
-                        while (read < contentLength) {
-                            int r = reader.read(content, read, contentLength - read);
-                            if (r == -1) break;
-                            read += r;
-                        }
-
-                        String jsonContent = new String(content);
-                        log.debug("pylsp 响应: {}", jsonContent);
-
-                        // 发送到 WebSocket
-                        if (socket != null && running.get()) {
-                            socket.write(Buffer.buffer(jsonContent));
-                        }
-                    }
-                }
-            } catch (Exception e) {
-                if (running.get()) {
-                    log.error("读取 pylsp 输出失败", e);
-                }
-            }
-        }
-
-        /**
-         * 读取 pylsp 错误输出
-         */
-        private void readLspError() {
-            try {
-                InputStream errorStream = process.getErrorStream();
-                BufferedReader reader = new BufferedReader(
-                    new InputStreamReader(errorStream, StandardCharsets.UTF_8)
-                );
-
-                String line;
-                while (running.get() && (line = reader.readLine()) != null) {
-                    log.debug("pylsp stderr: {}", line);
-                }
-            } catch (Exception e) {
-                if (running.get()) {
-                    log.error("读取 pylsp 错误输出失败", e);
-                }
-            }
-        }
-
-        /**
-         * 停止 pylsp 会话
-         */
-        public void stop() {
-            running.set(false);
-
-            try {
-                if (processWriter != null) {
-                    processWriter.close();
-                }
-            } catch (IOException e) {
-                // ignore
-            }
-
-            if (process != null && process.isAlive()) {
-                process.destroy();
-                try {
-                    // 等待进程结束
-                    if (!process.waitFor(5, java.util.concurrent.TimeUnit.SECONDS)) {
-                        process.destroyForcibly();
-                    }
-                } catch (InterruptedException e) {
-                    process.destroyForcibly();
-                }
-            }
-
-            log.info("pylsp 会话已停止: {}", sessionId);
-        }
-    }
-
-    /**
-     * 获取当前活跃的 pylsp 会话数
-     */
-    public static int getActiveSessionCount() {
-        return sessions.size();
-    }
-}

web-service/src/main/java/cn/qaiu/lz/web/controller/ServerApi.java

@@ -42,14 +42,13 @@ public class ServerApi {
         return promise.future();
     }
 
-    // order=2000 确保此路由优先于 /json/:type/:key 匹配（数字越大越先注册）
-    @RouteMapping(value = "/json/parser", method = RouteMethod.GET, order = 2000)
+    @RouteMapping(value = "/json/parser", method = RouteMethod.GET, order = 1)
     public Future<CacheLinkInfo> parseJson(HttpServerRequest request, String pwd) {
         String url = URLParamUtil.parserParams(request);
         return cacheService.getCachedByShareUrlAndPwd(url, pwd, JsonObject.of("UA",request.headers().get("user-agent")));
     }
 
-    @RouteMapping(value = "/json/:type/:key", method = RouteMethod.GET, order = 1000)
+    @RouteMapping(value = "/json/:type/:key", method = RouteMethod.GET)
     public Future<CacheLinkInfo> parseKeyJson(HttpServerRequest request, String type, String key) {
         String pwd = "";
         if (key.contains("@")) {
@@ -60,7 +59,7 @@ public class ServerApi {
         return cacheService.getCachedByShareKeyAndPwd(type, key, pwd, JsonObject.of("UA",request.headers().get("user-agent")));
     }
 
-    @RouteMapping(value = "/:type/:key", method = RouteMethod.GET, order = 1000)
+    @RouteMapping(value = "/:type/:key", method = RouteMethod.GET)
     public Future<Void> parseKey(HttpServerResponse response, HttpServerRequest request, String type, String key) {
         Promise<Void> promise = Promise.promise();
         String pwd = "";

web-service/src/main/java/cn/qaiu/lz/web/model/PlaygroundParser.java

@@ -2,7 +2,6 @@ package cn.qaiu.lz.web.model;
 
 import cn.qaiu.db.ddl.Constraint;
 import cn.qaiu.db.ddl.Length;
-import cn.qaiu.db.ddl.NewField;
 import cn.qaiu.db.ddl.Table;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Data;
@@ -47,12 +46,7 @@ public class PlaygroundParser {
 
     @Length(varcharSize = 65535)
     @Constraint(notNull = true)
-    private String jsCode; // JavaScript/Python代码
-
-    @NewField("脚本语言类型")
-    @Length(varcharSize = 32)
-    @Constraint(defaultValue = "javascript")
-    private String language; // 脚本语言: javascript 或 python
+    private String jsCode; // JavaScript代码
 
     @Length(varcharSize = 64)
     private String ip; // 创建者IP

web-service/src/main/java/cn/qaiu/lz/web/service/DbService.java

@@ -50,14 +50,4 @@ public interface DbService extends BaseAsyncService {
      */
     Future<JsonObject> getPlaygroundParserById(Long id);
 
-    /**
-     * 根据type查询解析器是否存在
-     */
-    Future<Boolean> existsPlaygroundParserByType(String type);
-
-    /**
-     * 初始化示例解析器（JS和Python）
-     */
-    Future<Void> initExampleParsers();
-
 }

web-service/src/main/java/cn/qaiu/lz/web/service/impl/DbServiceImpl.java

@@ -90,7 +90,6 @@ public class DbServiceImpl implements DbService {
                 parser.put("version", row.getString("version"));
                 parser.put("matchPattern", row.getString("match_pattern"));
                 parser.put("jsCode", row.getString("js_code"));
-                parser.put("language", row.getString("language") != null ? row.getString("language") : "javascript");
                 parser.put("ip", row.getString("ip"));
                 // 将LocalDateTime转换为字符串格式，避免序列化为数组
                 var createTime = row.getLocalDateTime("create_time");
@@ -120,8 +119,8 @@ public class DbServiceImpl implements DbService {
         
         String sql = """
             INSERT INTO playground_parser 
-            (name, type, display_name, description, author, version, match_pattern, js_code, language, ip, create_time, enabled)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), ?)
+            (name, type, display_name, description, author, version, match_pattern, js_code, ip, create_time, enabled)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), ?)
             """;
 
         client.preparedQuery(sql)
@@ -134,7 +133,6 @@ public class DbServiceImpl implements DbService {
                 parser.getString("version"),
                 parser.getString("matchPattern"),
                 parser.getString("jsCode"),
-                parser.getString("language", "javascript"),
                 parser.getString("ip"),
                 parser.getBoolean("enabled", true)
             ))
@@ -244,7 +242,6 @@ public class DbServiceImpl implements DbService {
                     parser.put("version", row.getString("version"));
                     parser.put("matchPattern", row.getString("match_pattern"));
                     parser.put("jsCode", row.getString("js_code"));
-                    parser.put("language", row.getString("language") != null ? row.getString("language") : "javascript");
                     parser.put("ip", row.getString("ip"));
                     // 将LocalDateTime转换为字符串格式，避免序列化为数组
                     var createTime = row.getLocalDateTime("create_time");
@@ -268,278 +265,4 @@ public class DbServiceImpl implements DbService {
 
         return promise.future();
     }
-
-    @Override
-    public Future<Boolean> existsPlaygroundParserByType(String type) {
-        JDBCPool client = JDBCPoolInit.instance().getPool();
-        Promise<Boolean> promise = Promise.promise();
-        
-        String sql = "SELECT COUNT(*) as count FROM playground_parser WHERE type = ?";
-        
-        client.preparedQuery(sql)
-            .execute(Tuple.of(type))
-            .onSuccess(rows -> {
-                Integer count = rows.iterator().next().getInteger("count");
-                promise.complete(count > 0);
-            })
-            .onFailure(e -> {
-                log.error("existsPlaygroundParserByType failed", e);
-                promise.fail(e);
-            });
-        
-        return promise.future();
-    }
-
-    @Override
-    public Future<Void> initExampleParsers() {
-        Promise<Void> promise = Promise.promise();
-        
-        // JS 示例解析器代码
-        String jsExampleCode = """
-            // ==UserScript==
-            // @name         示例JS解析器
-            // @description  演示如何编写JavaScript解析器，访问 https://httpbin.org/html 获取HTML内容
-            // @type         example_js
-            // @displayName  JS示例
-            // @version      1.0.0
-            // @author       System
-            // @match        https?://httpbin\\.org/s/(?<KEY>\\w+)
-            // ==/UserScript==
-            
-            /**
-             * 解析单个文件下载链接
-             * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息对象
-             * @param {JsHttpClient} http - HTTP客户端实例
-             * @param {JsLogger} logger - 日志记录器实例
-             * @returns {string} 下载链接
-             */
-            function parse(shareLinkInfo, http, logger) {
-                logger.info("===== JS示例解析器 =====");
-                
-                var shareUrl = shareLinkInfo.getShareUrl();
-                var shareKey = shareLinkInfo.getShareKey();
-                logger.info("分享链接: " + shareUrl);
-                logger.info("分享Key: " + shareKey);
-                
-                // 使用内置HTTP客户端发送GET请求
-                var response = http.get("https://httpbin.org/html");
-                
-                if (response.statusCode() === 200) {
-                    var body = response.text();
-                    logger.info("获取到HTML内容，长度: " + body.length);
-                    
-                    // 提取标题
-                    var titleMatch = body.match(/<title>([^<]+)<\\/title>/i);
-                    var title = titleMatch ? titleMatch[1] : "未知标题";
-                    logger.info("页面标题: " + title);
-                    
-                    // 返回下载链接（示例：返回HTML页面URL）
-                    return "https://httpbin.org/html";
-                } else {
-                    logger.error("请求失败，状态码: " + response.statusCode());
-                    throw new Error("请求失败: " + response.statusCode());
-                }
-            }
-            
-            /**
-             * 解析文件列表（可选）
-             * @param {ShareLinkInfo} shareLinkInfo - 分享链接信息对象
-             * @param {JsHttpClient} http - HTTP客户端实例
-             * @param {JsLogger} logger - 日志记录器实例
-             * @returns {FileInfo[]} 文件信息列表
-             */
-            function parseFileList(shareLinkInfo, http, logger) {
-                logger.info("===== 解析文件列表 =====");
-                
-                var response = http.get("https://httpbin.org/json");
-                var data = response.json();
-                
-                // 返回文件列表
-                return [{
-                    fileName: "example.html",
-                    fileId: "1",
-                    fileType: "file",
-                    size: 1024,
-                    sizeStr: "1 KB",
-                    parserUrl: "https://httpbin.org/html"
-                }];
-            }
-            """;
-        
-        // Python 示例解析器代码
-        String pyExampleCode = """
-            # ==UserScript==
-            # @name         示例Python解析器
-            # @type         example_py
-            # @displayName  Python示例
-            # @description  演示如何编写Python解析器，使用requests库和正则表达式
-            # @match        https?://httpbin\\.org/s/(?P<KEY>\\w+)
-            # @author       System
-            # @version      1.0.0
-            # ==/UserScript==
-            
-            \"\"\"
-            Python解析器示例 - 使用GraalPy运行
-            
-            可用模块：
-            - requests: HTTP请求库 (已内置，支持 get/post/put/delete 等)
-            - re: 正则表达式
-            - json: JSON处理
-            - base64: Base64编解码
-            - hashlib: 哈希算法
-            
-            内置对象：
-            - share_link_info: 分享链接信息
-            - http: 底层HTTP客户端（PyHttpClient）
-            - logger: 日志记录器（PyLogger）
-            - crypto: 加密工具 (md5/sha1/sha256/aes/base64)
-            \"\"\"
-            
-            import requests
-            import re
-            import json
-            
-            def parse(share_link_info, http, logger):
-                \"\"\"
-                解析单个文件下载链接
-                
-                Args:
-                    share_link_info: 分享链接信息对象
-                    http: HTTP客户端
-                    logger: 日志记录器
-                
-                Returns:
-                    str: 直链下载地址
-                \"\"\"
-                url = share_link_info.get_share_url()
-                key = share_link_info.get_share_key()
-                pwd = share_link_info.get_share_password()
-                
-                logger.info("===== Python示例解析器 =====")
-                logger.info(f"分享链接: {url}")
-                logger.info(f"分享Key: {key}")
-                
-                # 方式1：使用 requests 库发起请求（推荐）
-                response = requests.get('https://httpbin.org/html', headers={
-                    "Referer": url,
-                    "User-Agent": "Mozilla/5.0"
-                })
-                
-                if response.status_code != 200:
-                    logger.error(f"请求失败: {response.status_code}")
-                    raise Exception(f"请求失败: {response.status_code}")
-                
-                html = response.text
-                logger.info(f"获取到HTML内容，长度: {len(html)}")
-                
-                # 示例：使用正则表达式提取标题
-                match = re.search(r'<title>([^<]+)</title>', html, re.IGNORECASE)
-                if match:
-                    title = match.group(1)
-                    logger.info(f"页面标题: {title}")
-                
-                # 方式2：使用内置HTTP客户端（适合简单场景）
-                # json_response = http.get("https://httpbin.org/json")
-                # data = json_response.json()
-                # logger.info(f"JSON数据: {data.get('slideshow', {}).get('title', '未知')}")
-                
-                # 返回下载链接
-                return "https://httpbin.org/html"
-            
-            def parse_file_list(share_link_info, http, logger):
-                \"\"\"
-                解析文件列表（可选）
-            
-                Args:
-                    share_link_info: 分享链接信息对象
-                    http: HTTP客户端
-                    logger: 日志记录器
-            
-                Returns:
-                    list: 文件信息列表
-                \"\"\"
-                dir_id = share_link_info.get_other_param("dirId") or "0"
-                logger.info(f"解析文件列表，目录ID: {dir_id}")
-                
-                # 使用requests获取文件列表
-                response = requests.get('https://httpbin.org/json')
-                data = response.json()
-                
-                # 构建文件列表
-                file_list = [
-                    {
-                        "fileName": "example.html",
-                        "fileId": "1",
-                        "fileType": "file",
-                        "size": 2048,
-                        "sizeStr": "2 KB",
-                        "createTime": "2026-01-15 12:00:00",
-                        "parserUrl": "https://httpbin.org/html"
-                    },
-                    {
-                        "fileName": "subfolder",
-                        "fileId": "2",
-                        "fileType": "folder",
-                        "size": 0,
-                        "sizeStr": "-",
-                        "parserUrl": ""
-                    }
-                ]
-                
-                logger.info(f"返回 {len(file_list)} 个文件/文件夹")
-                return file_list
-            """;
-        
-        // 先检查JS示例是否存在
-        existsPlaygroundParserByType("example_js").compose(jsExists -> {
-            if (jsExists) {
-                log.info("JS示例解析器已存在，跳过初始化");
-                return Future.succeededFuture();
-            }
-            // 插入JS示例解析器
-            JsonObject jsParser = new JsonObject()
-                .put("name", "示例JS解析器")
-                .put("type", "example_js")
-                .put("displayName", "JS示例")
-                .put("description", "演示如何编写JavaScript解析器")
-                .put("author", "System")
-                .put("version", "1.0.0")
-                .put("matchPattern", "https?://httpbin\\.org/s/(?<KEY>\\w+)")
-                .put("jsCode", jsExampleCode)
-                .put("language", "javascript")
-                .put("ip", "127.0.0.1")
-                .put("enabled", false);  // 默认禁用，避免干扰正常解析
-            return savePlaygroundParser(jsParser);
-        }).compose(v -> {
-            // 检查Python示例是否存在
-            return existsPlaygroundParserByType("example_py");
-        }).compose(pyExists -> {
-            if (pyExists) {
-                log.info("Python示例解析器已存在，跳过初始化");
-                return Future.succeededFuture();
-            }
-            // 插入Python示例解析器
-            JsonObject pyParser = new JsonObject()
-                .put("name", "示例Python解析器")
-                .put("type", "example_py")
-                .put("displayName", "Python示例")
-                .put("description", "演示如何编写Python解析器")
-                .put("author", "System")
-                .put("version", "1.0.0")
-                .put("matchPattern", "https?://httpbin\\.org/s/(?P<KEY>\\w+)")
-                .put("jsCode", pyExampleCode)
-                .put("language", "python")
-                .put("ip", "127.0.0.1")
-                .put("enabled", false);  // 默认禁用，避免干扰正常解析
-            return savePlaygroundParser(pyParser);
-        }).onSuccess(v -> {
-            log.info("示例解析器初始化完成");
-            promise.complete();
-        }).onFailure(e -> {
-            log.error("初始化示例解析器失败", e);
-            promise.fail(e);
-        });
-        
-        return promise.future();
-    }
 }

web-service/src/test/java/cn/qaiu/lz/web/playground/PyPlaygroundTest.java

@@ -1,304 +0,0 @@
-package cn.qaiu.lz.web.playground;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-import cn.qaiu.parser.custompy.PyContextPool;
-import cn.qaiu.parser.custompy.PyPlaygroundExecutor;
-import cn.qaiu.parser.custompy.PyPlaygroundLogger;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.Assert.*;
-
-/**
- * Python 演练场单元测试
- * 测试 GraalPy 环境和代码执行
- */
-public class PyPlaygroundTest {
-    
-    private static final Logger log = LoggerFactory.getLogger(PyPlaygroundTest.class);
-    
-    @BeforeClass
-    public static void setup() {
-        log.info("初始化 PyContextPool...");
-        // 预热 Context Pool
-        PyContextPool.getInstance();
-    }
-    
-    /**
-     * 测试基础的 Context 创建和 Python 代码执行
-     */
-    @Test
-    public void testBasicPythonExecution() {
-        log.info("=== 测试基础 Python 执行 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试简单的 Python 表达式
-            Value result = context.eval("python", "1 + 2");
-            assertEquals(3, result.asInt());
-            log.info("✓ 基础 Python 表达式执行成功: 1 + 2 = {}", result.asInt());
-            
-            // 测试字符串操作
-            Value strResult = context.eval("python", "'hello'.upper()");
-            assertEquals("HELLO", strResult.asString());
-            log.info("✓ 字符串操作成功: 'hello'.upper() = {}", strResult.asString());
-        }
-    }
-    
-    /**
-     * 测试 requests 库导入
-     */
-    @Test
-    public void testRequestsImport() {
-        log.info("=== 测试 requests 库导入 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试 requests 导入
-            context.eval("python", "import requests");
-            log.info("✓ requests 导入成功");
-            
-            // 验证 requests 版本
-            Value version = context.eval("python", "requests.__version__");
-            log.info("✓ requests 版本: {}", version.asString());
-            assertNotNull(version.asString());
-        }
-    }
-    
-    /**
-     * 测试标准库导入
-     */
-    @Test
-    public void testStandardLibraries() {
-        log.info("=== 测试标准库导入 ===");
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 测试 json
-            context.eval("python", "import json");
-            Value jsonResult = context.eval("python", "json.dumps({'a': 1})");
-            assertEquals("{\"a\": 1}", jsonResult.asString());
-            log.info("✓ json 库工作正常");
-            
-            // 测试 re
-            context.eval("python", "import re");
-            Value reResult = context.eval("python", "bool(re.match(r'\\d+', '123'))");
-            assertTrue(reResult.asBoolean());
-            log.info("✓ re 库工作正常");
-            
-            // 测试 base64
-            context.eval("python", "import base64");
-            Value b64Result = context.eval("python", "base64.b64encode(b'hello').decode()");
-            assertEquals("aGVsbG8=", b64Result.asString());
-            log.info("✓ base64 库工作正常");
-        }
-    }
-    
-    /**
-     * 测试简单的 parse 函数执行
-     */
-    @Test
-    public void testSimpleParseFunction() {
-        log.info("=== 测试简单 parse 函数 ===");
-        
-        String pyCode = """
-            def parse(share_link_info, http, logger):
-                logger.info("测试开始")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            // 创建必要的对象
-            ShareLinkInfo shareLinkInfo = ShareLinkInfo.newBuilder()
-                .shareUrl("https://example.com/s/abc")
-                .build();
-            
-            PyPlaygroundLogger logger = new PyPlaygroundLogger();
-            
-            // 注入对象
-            Value bindings = context.getBindings("python");
-            bindings.putMember("logger", logger);
-            
-            // 执行代码定义函数
-            context.eval("python", pyCode);
-            
-            // 获取并调用 parse 函数
-            Value parseFunc = bindings.getMember("parse");
-            assertNotNull("parse 函数应该存在", parseFunc);
-            assertTrue("parse 应该是可执行的", parseFunc.canExecute());
-            
-            // 执行函数
-            Value result = parseFunc.execute(null, null, logger);
-            
-            assertEquals("https://example.com/download/test.zip", result.asString());
-            log.info("✓ parse 函数执行成功，返回: {}", result.asString());
-            
-            // 检查日志
-            assertFalse("应该有日志记录", logger.getLogs().isEmpty());
-            log.info("✓ 日志记录数: {}", logger.getLogs().size());
-        }
-    }
-    
-    /**
-     * 测试带 requests 的 parse 函数
-     */
-    @Test
-    public void testParseWithRequests() {
-        log.info("=== 测试带 requests 的 parse 函数 ===");
-        
-        // 使用一个简单的模板，不实际发起网络请求
-        String pyCode = """
-            import requests
-            import json
-            
-            def parse(share_link_info, http, logger):
-                logger.info("开始解析")
-                
-                # 验证 requests 可用
-                logger.info(f"requests 版本: {requests.__version__}")
-                
-                # 返回测试结果
-                return "https://example.com/download/file.zip"
-            """;
-        
-        PyContextPool pool = PyContextPool.getInstance();
-        
-        try (Context context = pool.createFreshContext()) {
-            PyPlaygroundLogger logger = new PyPlaygroundLogger();
-            
-            Value bindings = context.getBindings("python");
-            bindings.putMember("logger", logger);
-            
-            // 执行代码
-            context.eval("python", pyCode);
-            
-            // 调用 parse
-            Value parseFunc = bindings.getMember("parse");
-            assertNotNull(parseFunc);
-            
-            Value result = parseFunc.execute(null, null, logger);
-            assertEquals("https://example.com/download/file.zip", result.asString());
-            
-            log.info("✓ 带 requests 的 parse 函数执行成功");
-            
-            // 打印日志
-            for (PyPlaygroundLogger.LogEntry entry : logger.getLogs()) {
-                log.info("  [{}] {}", entry.getLevel(), entry.getMessage());
-            }
-        }
-    }
-    
-    /**
-     * 测试完整的 PyPlaygroundExecutor
-     */
-    @Test
-    public void testPyPlaygroundExecutor() throws Exception {
-        log.info("=== 测试 PyPlaygroundExecutor ===");
-        
-        String pyCode = """
-            import json
-            
-            def parse(share_link_info, http, logger):
-                url = share_link_info.get_share_url()
-                logger.info(f"解析链接: {url}")
-                return "https://example.com/download/test.zip"
-            """;
-        
-        // 创建 ShareLinkInfo
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        // 创建执行器
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-        
-        // 异步执行
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        // 等待结果
-        assertTrue("执行应该在 30 秒内完成", latch.await(30, TimeUnit.SECONDS));
-        
-        // 检查结果
-        if (errorRef.get() != null) {
-            log.error("执行失败", errorRef.get());
-            fail("执行失败: " + errorRef.get().getMessage());
-        }
-        
-        assertEquals("https://example.com/download/test.zip", resultRef.get());
-        log.info("✓ PyPlaygroundExecutor 执行成功，返回: {}", resultRef.get());
-        
-        // 检查日志
-        log.info("✓ 执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("  [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-    
-    /**
-     * 测试安全检查器拦截危险代码
-     */
-    @Test
-    public void testSecurityCheckerBlocks() throws Exception {
-        log.info("=== 测试安全检查器拦截 ===");
-        
-        String dangerousCode = """
-            import subprocess
-            
-            def parse(share_link_info, http, logger):
-                result = subprocess.run(['ls'], capture_output=True)
-                return result.stdout.decode()
-            """;
-        
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-        
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, dangerousCode);
-        
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-        
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-        
-        assertTrue("执行应该在 30 秒内完成", latch.await(30, TimeUnit.SECONDS));
-        
-        // 应该被安全检查器拦截
-        assertNotNull("应该抛出异常", errorRef.get());
-        assertTrue("应该是安全检查失败", 
-            errorRef.get().getMessage().contains("安全检查") || 
-            errorRef.get().getMessage().contains("subprocess"));
-        
-        log.info("✓ 安全检查器正确拦截了危险代码: {}", errorRef.get().getMessage());
-    }
-}

web-service/src/test/java/cn/qaiu/lz/web/playground/RequestsIntegrationTest.java

@@ -1,415 +0,0 @@
-package cn.qaiu.lz.web.playground;
-
-import cn.qaiu.entity.ShareLinkInfo;
-import cn.qaiu.parser.ParserCreate;
-import cn.qaiu.parser.custompy.PyContextPool;
-import cn.qaiu.parser.custompy.PyPlaygroundExecutor;
-import cn.qaiu.parser.custompy.PyPlaygroundLogger;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Value;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.Assert.*;
-
-/**
- * requests 库集成测试
- * 
- * 测试 Python 代码在 API 场景下使用 requests 库的功能
- * 验证 GraalPy 环境中 requests 库的可用性
- */
-public class RequestsIntegrationTest {
-
-    private static final Logger log = LoggerFactory.getLogger(RequestsIntegrationTest.class);
-
-    @BeforeClass
-    public static void setup() {
-        log.info("初始化 PyContextPool...");
-        PyContextPool.getInstance();
-    }
-
-    /**
-     * 测试1: 基础 requests 导入
-     * 验证 requests 库可以在顶层导入
-     */
-    @Test
-    public void testRequestsBasicImport() throws Exception {
-        log.info("=== 测试1: 基础 requests 导入 ===");
-
-        String pyCode = """
-            import requests
-            
-            def parse(share_link_info, http, logger):
-                logger.info(f"requests 版本: {requests.__version__}")
-                return "https://example.com/download.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/download.zip", "requests 顶层导入");
-    }
-
-    /**
-     * 测试2: requests.Session 创建
-     * 验证可以创建和使用 Session
-     */
-    @Test
-    public void testRequestsSession() throws Exception {
-        log.info("=== 测试2: requests.Session 创建 ===");
-
-        String pyCode = """
-            import requests
-            
-            def parse(share_link_info, http, logger):
-                session = requests.Session()
-                session.headers.update({
-                    'User-Agent': 'TestBot/1.0',
-                    'Accept': 'application/json'
-                })
-                logger.info("Session 创建成功")
-                logger.info(f"Headers: {dict(session.headers)}")
-                return "https://example.com/session.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/session.zip", "Session 创建");
-    }
-
-    /**
-     * 测试3: requests GET 请求（模拟）
-     * 不发起真实网络请求，验证请求构建逻辑
-     */
-    @Test
-    public void testRequestsGetPrepare() throws Exception {
-        log.info("=== 测试3: requests GET 请求准备 ===");
-
-        String pyCode = """
-            import requests
-            
-            def parse(share_link_info, http, logger):
-                # 准备请求，但不发送
-                req = requests.Request('GET', 'https://api.example.com/data', 
-                    headers={'Authorization': 'Bearer test'},
-                    params={'id': '123'}
-                )
-                prepared = req.prepare()
-                logger.info(f"请求 URL: {prepared.url}")
-                logger.info(f"请求方法: {prepared.method}")
-                return "https://example.com/prepared.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/prepared.zip", "GET 请求准备");
-    }
-
-    /**
-     * 测试4: requests POST 请求（模拟）
-     */
-    @Test
-    public void testRequestsPostPrepare() throws Exception {
-        log.info("=== 测试4: requests POST 请求准备 ===");
-
-        String pyCode = """
-            import requests
-            import json
-            
-            def parse(share_link_info, http, logger):
-                data = {'username': 'test', 'password': 'secret'}
-                
-                req = requests.Request('POST', 'https://api.example.com/login',
-                    json=data,
-                    headers={'Content-Type': 'application/json'}
-                )
-                prepared = req.prepare()
-                logger.info(f"请求 URL: {prepared.url}")
-                logger.info(f"请求体: {prepared.body}")
-                return "https://example.com/post.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/post.zip", "POST 请求准备");
-    }
-
-    /**
-     * 测试5: 完整的解析脚本模板
-     * 模拟真实的网盘解析脚本结构
-     */
-    @Test
-    public void testFullParserTemplate() throws Exception {
-        log.info("=== 测试5: 完整解析脚本模板 ===");
-
-        String pyCode = """
-            import requests
-            import re
-            import json
-            
-            def parse(share_link_info, http, logger):
-                \"\"\"
-                解析单个文件
-                @match https://example\\.com/s/.*
-                @name ExampleParser
-                @version 1.0.0
-                \"\"\"
-                share_url = share_link_info.get_share_url()
-                logger.info(f"开始解析: {share_url}")
-                
-                # 创建会话
-                session = requests.Session()
-                session.headers.update({
-                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
-                    'Accept': 'text/html,application/json',
-                    'Accept-Language': 'zh-CN,zh;q=0.9'
-                })
-                
-                # 模拟从URL提取文件ID
-                match = re.search(r'/s/([a-zA-Z0-9]+)', share_url)
-                if not match:
-                    raise Exception("无法提取文件ID")
-                
-                file_id = match.group(1)
-                logger.info(f"提取文件ID: {file_id}")
-                
-                # 模拟构建API请求
-                api_url = f"https://api.example.com/file/{file_id}"
-                logger.info(f"API URL: {api_url}")
-                
-                # 返回模拟的下载链接
-                download_url = f"https://download.example.com/{file_id}/file.zip"
-                logger.info(f"下载链接: {download_url}")
-                
-                return download_url
-            """;
-
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/abc123def");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-
-        assertTrue("执行应在30秒内完成", latch.await(30, TimeUnit.SECONDS));
-
-        if (errorRef.get() != null) {
-            log.error("执行失败", errorRef.get());
-            fail("执行失败: " + errorRef.get().getMessage());
-        }
-
-        String result = resultRef.get();
-        assertNotNull("结果不应为空", result);
-        assertTrue("结果应包含文件ID", result.contains("abc123def"));
-        log.info("✓ 完整解析脚本执行成功: {}", result);
-
-        // 打印日志
-        log.info("  执行日志:");
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("    [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-
-    /**
-     * 测试6: 多次 requests 操作
-     */
-    @Test
-    public void testMultipleRequestsOperations() throws Exception {
-        log.info("=== 测试6: 多次 requests 操作 ===");
-
-        String pyCode = """
-            import requests
-            import json
-            
-            def parse(share_link_info, http, logger):
-                # 创建多个请求
-                urls = [
-                    "https://api1.example.com/data",
-                    "https://api2.example.com/info",
-                    "https://api3.example.com/file"
-                ]
-                
-                results = []
-                for url in urls:
-                    req = requests.Request('GET', url)
-                    prepared = req.prepare()
-                    results.append(prepared.url)
-                    logger.info(f"准备请求: {prepared.url}")
-                
-                logger.info(f"共准备 {len(results)} 个请求")
-                return "https://example.com/multi.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/multi.zip", "多次 requests 操作");
-    }
-
-    /**
-     * 测试7: requests 异常处理
-     */
-    @Test
-    public void testRequestsExceptionHandling() throws Exception {
-        log.info("=== 测试7: requests 异常处理 ===");
-
-        String pyCode = """
-            import requests
-            
-            def parse(share_link_info, http, logger):
-                try:
-                    # 尝试创建无效请求
-                    req = requests.Request('INVALID_METHOD', 'not_a_url')
-                    logger.info("创建了请求")
-                except Exception as e:
-                    logger.warn(f"预期的异常: {type(e).__name__}")
-                
-                return "https://example.com/exception.zip"
-            """;
-
-        executeAndVerify(pyCode, "https://example.com/exception.zip", "异常处理");
-    }
-
-    /**
-     * 测试8: ShareLinkInfo 与 requests 结合使用
-     */
-    @Test
-    public void testShareLinkInfoWithRequests() throws Exception {
-        log.info("=== 测试8: ShareLinkInfo 与 requests 结合 ===");
-
-        String pyCode = """
-            import requests
-            import json
-            
-            def parse(share_link_info, http, logger):
-                share_url = share_link_info.get_share_url()
-                share_key = share_link_info.get_share_key() or "default_key"
-                
-                logger.info(f"分享链接: {share_url}")
-                logger.info(f"分享密钥: {share_key}")
-                
-                # 使用 share_url 构建请求
-                session = requests.Session()
-                
-                # 模拟提取信息
-                if 'example.com' in share_url:
-                    return "https://download.example.com/file.zip"
-                return None
-            """;
-
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/test");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-
-        assertTrue(latch.await(30, TimeUnit.SECONDS));
-
-        if (errorRef.get() != null) {
-            fail("执行失败: " + errorRef.get().getMessage());
-        }
-
-        assertEquals("https://download.example.com/file.zip", resultRef.get());
-        log.info("✓ ShareLinkInfo 与 requests 结合使用成功");
-    }
-
-    // ========== 辅助方法 ==========
-
-    /**
-     * 执行代码并验证结果
-     */
-    private void executeAndVerify(String pyCode, String expectedResult, String testName) throws Exception {
-        ParserCreate parserCreate = ParserCreate.fromShareUrl("https://example.com/s/test123");
-        ShareLinkInfo shareLinkInfo = parserCreate.getShareLinkInfo();
-
-        PyPlaygroundExecutor executor = new PyPlaygroundExecutor(shareLinkInfo, pyCode);
-
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<String> resultRef = new AtomicReference<>();
-        AtomicReference<Throwable> errorRef = new AtomicReference<>();
-
-        executor.executeParseAsync()
-            .onSuccess(result -> {
-                resultRef.set(result);
-                latch.countDown();
-            })
-            .onFailure(e -> {
-                errorRef.set(e);
-                latch.countDown();
-            });
-
-        assertTrue("执行应在30秒内完成", latch.await(30, TimeUnit.SECONDS));
-
-        if (errorRef.get() != null) {
-            Throwable error = errorRef.get();
-            String errorMsg = error.getMessage();
-            
-            // 检查是否是已知的 GraalPy 限制
-            if (errorMsg != null && (errorMsg.contains("unicodedata") || errorMsg.contains("LLVM"))) {
-                log.warn("⚠️ GraalPy unicodedata/LLVM 限制，跳过测试: {}", testName);
-                log.warn("  错误: {}", errorMsg);
-                return; // 跳过此测试
-            }
-            
-            log.error("执行失败", error);
-            fail("执行失败: " + errorMsg);
-        }
-
-        assertEquals(expectedResult, resultRef.get());
-        log.info("✓ {} 测试通过: {}", testName, resultRef.get());
-
-        // 打印日志
-        for (PyPlaygroundLogger.LogEntry entry : executor.getLogs()) {
-            log.info("  [{}] {}", entry.getLevel(), entry.getMessage());
-        }
-    }
-
-    // ========== main 方法 ==========
-
-    public static void main(String[] args) {
-        log.info("======================================");
-        log.info("   requests 集成测试套件");
-        log.info("======================================");
-
-        org.junit.runner.Result result = org.junit.runner.JUnitCore.runClasses(RequestsIntegrationTest.class);
-
-        log.info("\n======================================");
-        log.info("             测试结果");
-        log.info("======================================");
-        log.info("运行测试数: {}", result.getRunCount());
-        log.info("失败测试数: {}", result.getFailureCount());
-        log.info("忽略测试数: {}", result.getIgnoreCount());
-        log.info("运行时间: {} ms", result.getRunTime());
-
-        if (result.wasSuccessful()) {
-            log.info("\n✅ 所有 {} 个测试通过!", result.getRunCount());
-        } else {
-            log.error("\n❌ {} 个测试失败:", result.getFailureCount());
-            for (org.junit.runner.notification.Failure failure : result.getFailures()) {
-                log.error("  - {}", failure.getTestHeader());
-                log.error("    错误: {}", failure.getMessage());
-            }
-        }
-
-        System.exit(result.wasSuccessful() ? 0 : 1);
-    }
-}

web-service/src/test/java/cn/qaiu/lz/web/playground/RunPlaygroundTests.java

@@ -1,50 +0,0 @@
-package cn.qaiu.lz.web.playground;
-
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.notification.Failure;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * 手动运行 Playground 测试
- * 绕过 maven surefire 的 skipTests 配置
- */
-public class RunPlaygroundTests {
-    
-    private static final Logger log = LoggerFactory.getLogger(RunPlaygroundTests.class);
-    
-    public static void main(String[] args) {
-        log.info("======================================");
-        log.info("     Python Playground 测试套件");
-        log.info("======================================");
-        
-        // 运行 PyPlaygroundTest
-        log.info("\n>>> 运行 PyPlaygroundTest...\n");
-        Result result = JUnitCore.runClasses(PyPlaygroundTest.class);
-        
-        // 输出结果
-        log.info("\n======================================");
-        log.info("             测试结果");
-        log.info("======================================");
-        log.info("运行测试数: {}", result.getRunCount());
-        log.info("失败测试数: {}", result.getFailureCount());
-        log.info("忽略测试数: {}", result.getIgnoreCount());
-        log.info("运行时间: {} ms", result.getRunTime());
-        
-        if (result.wasSuccessful()) {
-            log.info("\n✅ 所有测试通过!");
-        } else {
-            log.error("\n❌ 部分测试失败:");
-            for (Failure failure : result.getFailures()) {
-                log.error("  - {}: {}", failure.getTestHeader(), failure.getMessage());
-                if (failure.getTrace() != null) {
-                    log.error("    堆栈: {}", failure.getTrace().substring(0, Math.min(500, failure.getTrace().length())));
-                }
-            }
-        }
-        
-        // 退出码
-        System.exit(result.wasSuccessful() ? 0 : 1);
-    }
-}

web-service/src/test/python/test_playground_api.py

@@ -1,451 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Playground API 测试脚本 (使用 pytest)
-
-用于测试 /v2/playground/* 接口的功能，特别是 Python 脚本执行。
-需要后端服务运行在 http://localhost:8080
-
-安装依赖:
-    pip install pytest requests
-
-运行测试:
-    pytest test_playground_api.py -v
-
-或者运行特定测试:
-    pytest test_playground_api.py::test_status_api -v
-"""
-
-import pytest
-import requests
-import json
-import time
-
-# 配置
-BASE_URL = "http://localhost:8080"
-PLAYGROUND_BASE = f"{BASE_URL}/v2/playground"
-
-# 测试用的分享链接
-TEST_SHARE_URL = "https://www.123684.com/s/test123"
-
-
-class TestPlaygroundAPI:
-    """Playground API 测试类"""
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """测试前置：检查服务是否可用"""
-        try:
-            resp = requests.get(f"{PLAYGROUND_BASE}/status", timeout=5)
-            if resp.status_code != 200:
-                pytest.skip("后端服务不可用")
-        except requests.exceptions.ConnectionError:
-            pytest.skip("无法连接到后端服务")
-
-    def test_status_api(self):
-        """测试状态查询 API"""
-        resp = requests.get(f"{PLAYGROUND_BASE}/status")
-        assert resp.status_code == 200
-
-        data = resp.json()
-        assert "data" in data
-        assert "enabled" in data["data"]
-        print(f"状态响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-    def test_python_simple_code(self):
-        """测试简单 Python 代码执行"""
-        code = '''
-def parse(share_link_info, http, logger):
-    logger.info("简单测试开始")
-    return "https://example.com/download/test.zip"
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        # 检查执行结果
-        assert data.get("success") == True, f"执行失败: {data.get('error')}"
-        assert data.get("result") == "https://example.com/download/test.zip"
-
-    def test_python_with_json_library(self):
-        """测试使用 json 库的 Python 代码"""
-        code = '''
-import json
-
-def parse(share_link_info, http, logger):
-    data = {"url": "https://example.com/file.zip", "size": 1024}
-    logger.info(f"数据: {json.dumps(data)}")
-    return data["url"]
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        assert data.get("success") == True, f"执行失败: {data.get('error')}"
-        assert "example.com" in data.get("result", "")
-
-    def test_python_with_requests_import(self):
-        """测试导入 requests 库（不发起实际请求）"""
-        code = '''
-import requests
-
-def parse(share_link_info, http, logger):
-    logger.info(f"requests 版本: {requests.__version__}")
-    
-    # 只测试导入，不发起实际网络请求
-    return "https://example.com/download/file.zip"
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        # 注意: 由于 GraalPy 限制，此测试可能失败
-        if not data.get("success"):
-            print(f"⚠ requests 导入可能失败 (GraalPy 限制): {data.get('error')}")
-            pytest.skip("GraalPy requests 导入限制")
-
-        assert data.get("result") is not None
-
-    def test_python_with_requests_get(self):
-        """测试使用 requests 发起 GET 请求"""
-        code = '''
-import requests
-
-def parse(share_link_info, http, logger):
-    logger.info("开始 HTTP 请求测试")
-    
-    # 发起简单的 GET 请求
-    try:
-        resp = requests.get("https://httpbin.org/get", timeout=10)
-        logger.info(f"响应状态码: {resp.status_code}")
-        
-        if resp.status_code == 200:
-            return "https://example.com/success.zip"
-        else:
-            return None
-    except Exception as e:
-        logger.error(f"请求失败: {str(e)}")
-        return None
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload, timeout=60)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        # 检查日志
-        if "logs" in data:
-            for log_entry in data["logs"]:
-                print(f"  [{log_entry.get('level')}] {log_entry.get('message')}")
-
-        # 如果由于 GraalPy 限制失败，跳过测试
-        if not data.get("success"):
-            error = data.get("error", "")
-            if "unicodedata" in error or "LLVM" in error:
-                pytest.skip("GraalPy requests 限制")
-            pytest.fail(f"执行失败: {error}")
-
-    def test_python_security_block_subprocess(self):
-        """测试安全检查器拦截 subprocess"""
-        code = '''
-import subprocess
-
-def parse(share_link_info, http, logger):
-    result = subprocess.run(['ls'], capture_output=True)
-    return result.stdout.decode()
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        # 应该被安全检查器拦截
-        assert data.get("success") == False
-        assert "subprocess" in data.get("error", "").lower() or \
-               "安全" in data.get("error", "")
-
-    def test_python_security_block_os_system(self):
-        """测试安全检查器拦截 os.system"""
-        code = '''
-import os
-
-def parse(share_link_info, http, logger):
-    os.system("ls")
-    return "test"
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        # 应该被安全检查器拦截
-        assert data.get("success") == False
-
-    def test_python_with_logger(self):
-        """测试日志记录功能"""
-        code = '''
-def parse(share_link_info, http, logger):
-    logger.debug("这是 debug 消息")
-    logger.info("这是 info 消息")
-    logger.warn("这是 warn 消息")
-    logger.error("这是 error 消息")
-    return "https://example.com/logged.zip"
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        assert data.get("success") == True
-        assert "logs" in data
-        assert len(data["logs"]) >= 4, "应该有至少 4 条日志"
-
-        # 检查日志级别
-        log_levels = [log["level"] for log in data["logs"]]
-        assert "DEBUG" in log_levels or "debug" in log_levels
-        assert "INFO" in log_levels or "info" in log_levels
-
-    def test_empty_code_validation(self):
-        """测试空代码验证"""
-        payload = {
-            "code": "",
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        assert data.get("success") == False
-        assert "空" in data.get("error", "") or "empty" in data.get("error", "").lower()
-
-    def test_invalid_language(self):
-        """测试无效语言类型"""
-        payload = {
-            "code": "print('test')",
-            "shareUrl": TEST_SHARE_URL,
-            "language": "rust",  # 不支持的语言
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        assert data.get("success") == False
-        assert "不支持" in data.get("error", "") or "language" in data.get("error", "").lower()
-
-    def test_javascript_code(self):
-        """测试 JavaScript 代码执行"""
-        code = '''
-function parse(shareLinkInfo, http, logger) {
-    logger.info("JavaScript 测试");
-    return "https://example.com/js-result.zip";
-}
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "javascript",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        assert resp.status_code == 200
-
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        assert data.get("success") == True
-        assert "js-result" in data.get("result", "")
-
-
-class TestRequestsIntegration:
-    """requests 库集成测试"""
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """测试前置：检查服务是否可用"""
-        try:
-            resp = requests.get(f"{PLAYGROUND_BASE}/status", timeout=5)
-            if resp.status_code != 200:
-                pytest.skip("后端服务不可用")
-        except requests.exceptions.ConnectionError:
-            pytest.skip("无法连接到后端服务")
-
-    def test_requests_session(self):
-        """测试 requests.Session"""
-        code = '''
-import requests
-
-def parse(share_link_info, http, logger):
-    session = requests.Session()
-    session.headers.update({"User-Agent": "TestBot/1.0"})
-    logger.info("Session 创建成功")
-    return "https://example.com/session.zip"
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload)
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        if not data.get("success"):
-            error = data.get("error", "")
-            if "unicodedata" in error or "LLVM" in error:
-                pytest.skip("GraalPy requests 限制")
-            pytest.fail(f"执行失败: {error}")
-
-    def test_requests_post_json(self):
-        """测试 requests POST JSON"""
-        code = '''
-import requests
-import json
-
-def parse(share_link_info, http, logger):
-    data = {"test": "value"}
-    logger.info(f"准备 POST 数据: {json.dumps(data)}")
-    
-    try:
-        resp = requests.post(
-            "https://httpbin.org/post",
-            json=data,
-            timeout=10
-        )
-        logger.info(f"响应状态: {resp.status_code}")
-        return "https://example.com/post-success.zip"
-    except Exception as e:
-        logger.error(f"POST 请求失败: {str(e)}")
-        return None
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload, timeout=60)
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        if not data.get("success"):
-            error = data.get("error", "")
-            if "unicodedata" in error or "LLVM" in error:
-                pytest.skip("GraalPy requests 限制")
-
-    def test_requests_with_headers(self):
-        """测试 requests 自定义 headers"""
-        code = '''
-import requests
-
-def parse(share_link_info, http, logger):
-    headers = {
-        "User-Agent": "CustomBot/2.0",
-        "Accept": "application/json",
-        "X-Custom-Header": "TestValue"
-    }
-    
-    logger.info("准备发送带自定义 headers 的请求")
-    
-    try:
-        resp = requests.get(
-            "https://httpbin.org/headers",
-            headers=headers,
-            timeout=10
-        )
-        logger.info(f"响应: {resp.status_code}")
-        return "https://example.com/headers-success.zip"
-    except Exception as e:
-        logger.error(f"请求失败: {str(e)}")
-        return None
-'''
-        payload = {
-            "code": code,
-            "shareUrl": TEST_SHARE_URL,
-            "language": "python",
-            "method": "parse"
-        }
-
-        resp = requests.post(f"{PLAYGROUND_BASE}/test", json=payload, timeout=60)
-        data = resp.json()
-        print(f"响应: {json.dumps(data, ensure_ascii=False, indent=2)}")
-
-        if not data.get("success"):
-            error = data.get("error", "")
-            if "unicodedata" in error or "LLVM" in error:
-                pytest.skip("GraalPy requests 限制")
-
-
-if __name__ == "__main__":
-    # 直接运行测试
-    pytest.main([__file__, "-v", "--tb=short"])

webroot/test/sockTest.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="ZH-cn">
+<script src="sockjs-min.js"></script>
+<head>
+    <meta charset="UTF-8">
+    <title>测试021</title>
+</head>
+<body>
+<div>
+    <label>
+        <input id="input0"/>
+        <input type="button" value="发送" onclick="send()">
+    </label>
+</div>
+</body>
+<script>
+
+  var sock = new SockJS('http://127.0.0.1:8086/real/serverApi/test');
+
+  // 测试websocket直接http反向代理
+  // var sock = new SockJS('http://'+location.host+'/real/serverApi/test'); // 这会导致sockjs降级处理 (使用普通post轮询 模拟websocket)
+
+
+  sock.onopen = function () {
+    console.log('open');
+  };
+
+  function send() {
+
+    var v = document.getElementById("input0");
+    console.log('client:', v.value)
+    sock.send(v.value)
+  }
+
+  sock.onmessage = function (e) {
+    console.log('message', e.data);
+  };
+
+  sock.onevent = function (event, message) {
+    console.log('event: %o, message:%o', event, message);
+    return true; // 为了标记消息已被处理了
+  };
+
+  sock.onunhandled = function (json) {
+    console.log('this message has no address:', json);
+  };
+
+  sock.onclose = function () {
+    console.log('close');
+  };
+</script>
+</html>