hyapi-tester 0.1.2__py3-none-any.whl

hyapi_tester/__init__.py

@@ -0,0 +1,8 @@
+"""
+hyapi-tester —— 黑羽API 测试器。
+
+基于 PySide6 的桌面应用，通过 LLM 生成 Python 代码来发送 HTTP 请求、
+接收响应并在日志框中展示结果。
+"""
+
+__version__ = "0.1.2"

hyapi_tester/ai_qa_dialog.py

@@ -0,0 +1,379 @@
+"""
+AI 问答对话框：自由向 LLM 提问，可选附带日志框选中内容与接口文档。
+
+多轮上下文策略（折中方案）：
+- 保留最近 ``MAX_RECENT_TURNS`` 轮原始 (user, assistant) 对话；
+- AI 每轮以 JSON 返回 ``{answer, context}``，``context`` 是整理后的对话上下文摘要；
+- ``context`` 作为 system prompt 一部分，供后续轮次引用；
+- 旧轮次被压缩到 context 中后从 recent 列表移除；
+- 界面只显示 ``answer``，不显示 ``context``。
+"""
+
+import json
+
+from PySide6.QtCore import Qt, QPoint, QRect, QTimer
+from PySide6.QtGui import QColor, QPainter, QPen
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDialog,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPlainTextEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .llm_service import (
+    CancelToken,
+    call_llm_qa_stream_messages,
+    read_doc_files,
+)
+from .ui_icons import apply_icon
+from .widgets import HintLabel
+from .worker import CancellableWorker
+
+
+# 最近保留的原始对话轮数（超过此数的旧轮次已被压缩到 context 中）
+MAX_RECENT_TURNS = 4
+
+_QA_SYSTEM_PROMPT = (
+    "你是一名测试开发助手，请根据用户的问题提供准确、简明的解答。\n\n"
+    "你必须以 JSON 格式返回，格式如下：\n"
+    "{\n"
+    '  "answer": "对用户问题的回答（用户可见，支持 markdown）",\n'
+    '  "context": "整理后的对话上下文摘要，保留关键事实、决策、代码片段、调试发现等，便于后续问答引用（用户不可见）"\n'
+    "}\n\n"
+    "要求：\n"
+    "- 严格返回合法 JSON，不要在 JSON 外添加任何文字\n"
+    "- 不要使用 markdown 代码块（```）包裹 JSON\n"
+    "- answer 是对用户问题的直接回答\n"
+    "- context 应精炼，避免冗长，保留后续问答可能需要的关键信息\n"
+    "- 若无需整理上下文，context 可返回空字符串"
+)
+
+_SELECTION_HINT_PREFIX = (
+    "如果我的问题中提到类似：这些/这段文字/这段内容/选中内容 等等，是指如下内容：\n"
+)
+_DOC_HINT_PREFIX = "被测系统接口文档内容如下：\n"
+
+
+class Spinner(QWidget):
+    """轻量旋转弧线指示器（类似 Material Design 圆形进度）。"""
+
+    def __init__(self, parent=None, size=16, color="#4f6ef2", width=2):
+        super().__init__(parent)
+        self._angle = 0
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._tick)
+        self._timer.setInterval(30)
+        self._color = QColor(color)
+        self._pen_width = width
+        self.setFixedSize(size, size)
+        self.setVisible(False)
+
+    def _tick(self):
+        self._angle = (self._angle + 10) % 360
+        self.update()
+
+    def start(self):
+        self._timer.start()
+        self.setVisible(True)
+
+    def stop(self):
+        self._timer.stop()
+        self.setVisible(False)
+
+    def paintEvent(self, event):
+        r = min(self.width(), self.height())
+        margin = self._pen_width
+        dv = r // 2 - margin
+
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # 背景圈（极淡）
+        pen = QPen(self._color)
+        pen.setWidth(self._pen_width)
+        bg = QColor(self._color)
+        bg.setAlpha(30)
+        pen.setColor(bg)
+        painter.setPen(pen)
+        painter.drawEllipse(QPoint(r // 2, r // 2), dv, dv)
+
+        # 旋转弧
+        pen.setColor(self._color)
+        pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        painter.setPen(pen)
+        span = 120 * 16
+        start = self._angle * 16
+        painter.drawArc(QRect(margin, margin, dv * 2, dv * 2), start, span)
+        painter.end()
+
+
+class AIQADialog(QDialog):
+    """无模式 AI 问答对话框（多轮）。
+
+    - 多行输入框提问；
+    - 提交时若主窗口日志框有选中内容，自动附加到提示词；
+    - 可选勾选「带上接口文档」，将接口文档内容一并附上；
+    - 多轮上下文：最近 N 轮原始对话 + AI 整理的 context。
+    """
+
+    def __init__(self, parent, broker):
+        super().__init__(parent)
+        self.setWindowTitle("AI 问答")
+        self.setMinimumSize(700, 520)
+        self._parent = parent
+        self._broker = broker
+        self._worker: CancellableWorker | None = None
+        self._cancel_token: CancelToken | None = None
+        # 多轮上下文状态
+        self._context: str = ""
+        self._recent_turns: list[tuple[str, str]] = []
+        self._pending_question: str = ""
+        self._build_ui()
+
+    def _build_ui(self):
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+
+        layout.addWidget(HintLabel(
+            "向 AI 提问，支持多轮对话。若日志框当前有选中内容，会自动附到提示词中；"
+            "勾选「带上接口文档」可一并附带接口文档。"
+        ))
+
+        layout.addWidget(QLabel("你的问题："))
+        self.question_edit = QPlainTextEdit()
+        self.question_edit.setObjectName("prompt_editor")
+        self.question_edit.setPlaceholderText("请输入你的问题…")
+        layout.addWidget(self.question_edit)
+
+        opt_row = QHBoxLayout()
+        opt_row.setSpacing(10)
+        self.with_docs_check = QCheckBox("带上接口文档")
+        self.with_docs_check.setChecked(False)
+        opt_row.addWidget(self.with_docs_check)
+        opt_row.addStretch()
+        layout.addLayout(opt_row)
+
+        btn_row = QHBoxLayout()
+        btn_row.setSpacing(10)
+        self.ask_btn = QPushButton("提问")
+        self.ask_btn.setProperty("btnStyle", "primary")
+        apply_icon(self.ask_btn, "zap", "#ffffff")
+        self.ask_btn.clicked.connect(self._on_ask)
+        self.stop_btn = QPushButton("终止")
+        self.stop_btn.setProperty("btnStyle", "success")
+        apply_icon(self.stop_btn, "x", "#ffffff")
+        self.stop_btn.clicked.connect(self._on_stop)
+        self.stop_btn.setVisible(False)
+        self.clear_ctx_btn = QPushButton("清空上下文")
+        self.clear_ctx_btn.setProperty("btnStyle", "soft")
+        apply_icon(self.clear_ctx_btn, "rotate-ccw", "#4f6ef2")
+        self.clear_ctx_btn.clicked.connect(self._on_clear_context)
+        self.clear_ctx_btn.setToolTip("清空多轮对话上下文与历史")
+        close_btn = QPushButton("关闭")
+        apply_icon(close_btn, "x")
+        close_btn.clicked.connect(self.close)
+        btn_row.addWidget(self.ask_btn)
+        btn_row.addWidget(self.stop_btn)
+        btn_row.addWidget(self.clear_ctx_btn)
+        btn_row.addStretch()
+        btn_row.addWidget(close_btn)
+        layout.addLayout(btn_row)
+
+        answer_header = QHBoxLayout()
+        answer_header.addWidget(QLabel("AI 回答："))
+        self.busy_spinner = Spinner(self)
+        answer_header.addWidget(self.busy_spinner)
+        answer_header.addStretch()
+        layout.addLayout(answer_header)
+
+        self.answer_edit = QTextEdit()
+        self.answer_edit.setObjectName("log_text_edit")
+        self.answer_edit.setReadOnly(True)
+        layout.addWidget(self.answer_edit)
+
+    # ------------------------------------------------------------------
+    # 上下文管理
+    # ------------------------------------------------------------------
+    def _on_clear_context(self):
+        """清空多轮上下文与历史。"""
+        if self._worker is not None:
+            return
+        self._context = ""
+        self._recent_turns.clear()
+        self.answer_edit.clear()
+        self.question_edit.clear()
+
+    # ------------------------------------------------------------------
+    # 提交
+    # ------------------------------------------------------------------
+    def _collect_selected_log_text(self) -> str:
+        """从主窗口日志框提取当前选中的纯文本。"""
+        log_edit = getattr(self._parent, "log_text_edit", None)
+        if log_edit is None:
+            return ""
+        cursor = log_edit.textCursor()
+        if cursor is None or not cursor.hasSelection():
+            return ""
+        return cursor.selectedText().replace("\u2029", "\n").strip()
+
+    def _build_current_user_prompt(self, question: str, with_docs: bool) -> str:
+        """组装当前轮发送给 LLM 的 user 消息内容（不含历史）。"""
+        parts: list[str] = []
+
+        selected = self._collect_selected_log_text()
+        if selected:
+            parts.append(_SELECTION_HINT_PREFIX + selected)
+
+        if with_docs:
+            doc_paths = []
+            doc_list = getattr(self._parent, "doc_list", None)
+            if doc_list is not None:
+                for i in range(doc_list.count()):
+                    doc_paths.append(doc_list.item(i).data(Qt.ItemDataRole.UserRole))
+            if doc_paths:
+                doc_text = read_doc_files(doc_paths)
+                parts.append(_DOC_HINT_PREFIX + doc_text)
+            else:
+                QMessageBox.information(
+                    self, "无接口文档",
+                    "当前未添加接口文档，「带上接口文档」将被忽略。",
+                )
+
+        parts.append(question)
+        return "\n\n".join(parts)
+
+    def _build_messages(self, current_user_prompt: str) -> list:
+        """构造完整 messages：system(含 context) + 最近 N 轮历史 + 当前问题。"""
+        system = _QA_SYSTEM_PROMPT
+        if self._context:
+            system += "\n\n当前对话上下文：\n" + self._context
+        messages = [{"role": "system", "content": system}]
+
+        for user_text, answer_text in self._recent_turns[-MAX_RECENT_TURNS:]:
+            messages.append({"role": "user", "content": user_text})
+            messages.append({"role": "assistant", "content": answer_text})
+
+        messages.append({"role": "user", "content": current_user_prompt})
+        return messages
+
+    def _on_ask(self):
+        if self._worker is not None:
+            return
+
+        question = self.question_edit.toPlainText().strip()
+        if not question:
+            QMessageBox.warning(self, "内容为空", "请输入你的问题")
+            return
+
+        base_url = self._parent.llm_dialog.get_base_url()
+        api_key = self._parent.llm_dialog.get_api_key()
+        model = self._parent.model_combo.currentText().strip()
+        if not base_url:
+            QMessageBox.warning(self, "缺少配置", "请填写 LLM 服务的 base_url")
+            return
+        if not api_key:
+            QMessageBox.warning(self, "缺少配置", "请填写 LLM 服务的 api_key")
+            return
+        if not model:
+            QMessageBox.warning(self, "缺少配置", "请选择或填写 LLM 模型名称")
+            return
+
+        with_docs = self.with_docs_check.isChecked()
+        current_user_prompt = self._build_current_user_prompt(question, with_docs)
+        messages = self._build_messages(current_user_prompt)
+
+        # 清空回答区并显示进度条，结束后直接展示干净 answer
+        self.answer_edit.clear()
+        self._set_busy(True)
+        self._cancel_token = CancelToken()
+        self._pending_question = question
+
+        def do_call():
+            return call_llm_qa_stream_messages(
+                base_url, api_key, model, messages,
+                cancel_token=self._cancel_token,
+                use_responses_api=self._parent.llm_dialog.get_use_responses_api(),
+            )
+
+        self._worker = CancellableWorker(do_call)
+        self._worker.finished.connect(self._on_finished)
+        self._worker.error.connect(self._on_error)
+        self._worker.start()
+
+    @staticmethod
+    def _parse_qa_response(raw: str) -> tuple[str, str]:
+        """解析 AI 返回的 JSON，返回 (answer, context)。
+
+        解析失败时返回 (raw, "")，由调用方决定是否保留旧 context。
+        """
+        text = raw.strip()
+        # 去除可能的 markdown 代码块包裹
+        if text.startswith("```"):
+            lines = text.splitlines()
+            if lines and lines[0].startswith("```"):
+                lines = lines[1:]
+            if lines and lines[-1].strip() == "```":
+                lines = lines[:-1]
+            text = "\n".join(lines).strip()
+
+        try:
+            data = json.loads(text)
+            if isinstance(data, dict):
+                answer = str(data.get("answer", "")).strip()
+                context = str(data.get("context", "")).strip()
+                if answer:
+                    return answer, context
+        except Exception:
+            pass
+        return raw, ""
+
+    def _on_finished(self, raw_text: str):
+        answer, context = self._parse_qa_response(raw_text)
+        if context:
+            self._context = context
+        # 解析失败时 context 为空，保持旧 context 不变
+
+        self.answer_edit.setPlainText(answer)
+
+        # 记录本轮到历史（存纯问题，不含选中日志/文档）
+        self._recent_turns.append((self._pending_question, answer))
+        if len(self._recent_turns) > MAX_RECENT_TURNS:
+            self._recent_turns = self._recent_turns[-MAX_RECENT_TURNS:]
+
+        # 清空问题框，便于输入下一轮
+        self.question_edit.clear()
+        self._pending_question = ""
+        self._reset_state()
+
+    def _on_stop(self):
+        if self._cancel_token is not None:
+            self._cancel_token.cancel()
+        if self._worker is not None:
+            self._worker.cancel()
+
+    def _set_busy(self, busy: bool):
+        self.ask_btn.setVisible(not busy)
+        self.stop_btn.setVisible(busy)
+        self.clear_ctx_btn.setEnabled(not busy)
+        if busy:
+            self.busy_spinner.start()
+        else:
+            self.busy_spinner.stop()
+
+    def _on_error(self, error_msg: str):
+        if "终止" not in error_msg:
+            QMessageBox.critical(self, "AI 问答失败", error_msg)
+        self._pending_question = ""
+        self._reset_state()
+
+    def _reset_state(self):
+        self._worker = None
+        self._cancel_token = None
+        self._set_busy(False)

hyapi_tester/broker.py

@@ -0,0 +1,302 @@
+"""
+Broker 对象：作为 exec 执行 LLM 生成代码时的 globals 参数。
+
+提供全局的 HTTP Session（client）、被测系统 API 基地址，
+以及操作日志框、清理环境的方法。
+"""
+
+import json
+import traceback
+from typing import Any, Dict, Optional
+
+
+class SafeExit(Exception):
+    """由 exec 环境中的安全 exit() 抛出，不视为致命错误。"""
+    pass
+
+import requests
+from PySide6.QtCore import QObject, Signal
+
+
+# 日志颜色常量（使用 Qt 可识别的颜色名/十六进制）
+COLOR_BLACK = "#383a42"        # 默认
+COLOR_GREEN = "#228B22"        # 发送请求（森林绿，更醒目）
+COLOR_BLUE = "#0063C5"         # 接收响应（蓝）
+COLOR_TAN = "#C4A35A"          # LLM 流式输出（土黄色，更深更易辨认）
+COLOR_RED = "#CC0000"          # 错误
+COLOR_GRAY = "#808080"         # LLM 提示词（除接口文档外）
+
+
+class LogEmitter(QObject):
+    """日志信号发射器，跨线程把日志事件发送到主线程的日志控件。"""
+
+    # text, color, newline
+    append_text = Signal(str, str, bool)
+    clear_log = Signal()
+
+
+class Broker:
+    """
+    执行环境代理对象。
+
+    属性:
+        client: requests.Session 实例，自动维护服务端返回的 cookie。
+        api_url_base: 被测系统 API 基地址。
+        globals_vars: exec 运行时可以读写的用户全局变量存储区。
+    """
+
+    def __init__(self, api_url_base: str = "http://127.0.0.1"):
+        self.client: requests.Session = requests.Session()
+        self.config: dict = {}
+        self.globals_vars: Dict[str, Any] = {}
+        self.log_emitter = LogEmitter()
+        self._wrap_client_send()
+
+    def _wrap_client_send(self):
+        """包装 Session.send，在发送前打印请求、返回后打印响应。"""
+        original_send = self.client.send
+        original_request = self.client.request
+        broker = self
+
+        def logged_request(method, url, **kwargs):
+            if kwargs.get("timeout") is None:
+                kwargs["timeout"] = 10
+            return original_request(method, url, **kwargs)
+
+        def logged_send(request, **kwargs):
+            if kwargs.get("timeout") is None:
+                kwargs["timeout"] = 10
+            broker._log_prepared_request(request)
+            try:
+                response = original_send(request, **kwargs)
+                broker._log_response(response)
+                return response
+            except Exception:
+                broker.log(f"请求失败: {request.method} {request.url}", COLOR_RED)
+                raise
+
+        self.client.request = logged_request
+        self.client.send = logged_send
+
+    def _log_prepared_request(self, req):
+        """打印 PreparedRequest 的完整内容。"""
+        lines = [f"请求: {req.method} {req.url}"]
+        if req.headers:
+            lines.append("请求头:")
+            for k, v in req.headers.items():
+                lines.append(f"  {k}: {v}")
+        body = req.body
+        if body is not None:
+            if isinstance(body, bytes):
+                try:
+                    body = body.decode("utf-8")
+                except Exception:
+                    body = f"<binary {len(body)} bytes>"
+            lines.append("请求体:")
+            lines.append(self._format_body(body))
+        self.log("\n".join(lines), COLOR_GREEN)
+
+    def _log_response(self, response):
+        """打印 Response 的基本信息。"""
+        lines = [
+            f"响应: HTTP {response.status_code} {response.reason}",
+            "响应头:",
+            json.dumps(dict(response.headers), ensure_ascii=False, indent=2),
+            "响应体:",
+            self._format_body(response.text),
+        ]
+        self.log("\n".join(lines), COLOR_BLUE)
+
+    # ------------------------------------------------------------------
+    # 日志操作
+    # ------------------------------------------------------------------
+    def log(self, message: Any, color: Optional[str] = None):
+        """在日志框中追加一条消息（自动换行）。
+
+        若未指定 color，使用默认黑色。
+        """
+        text = str(message)
+        resolved = color if color is not None else COLOR_BLACK
+        self.log_emitter.append_text.emit(str(text), self._normalize_color(resolved), True)
+
+
+    def log_raw(self, text: str, color: str = COLOR_TAN):
+        """在日志框中追加不带时间戳的文本，用于流式输出（默认不换行）。"""
+        self.log_emitter.append_text.emit(str(text), self._normalize_color(color), False)
+
+    def log_stream(self, chunk: str, color: str = COLOR_TAN):
+        """流式追加文本（与 log_raw 等效，语义更明确）。"""
+        self.log_raw(chunk, color)
+
+    def log_json(self, data: Any, title: Optional[str] = None, color: str = COLOR_BLACK):
+        """将对象以格式化 JSON 形式记录到日志框。"""
+        lines = []
+        if title:
+            lines.append(title)
+        try:
+            lines.append(json.dumps(data, ensure_ascii=False, indent=2))
+        except Exception:
+            lines.append(str(data))
+        self.log("\n".join(lines), color)
+
+    # def log_request(self, message: Any):
+    #     """记录请求信息，固定绿色。"""
+    #     self.log(message, COLOR_GREEN)
+    
+    # def log_response(self, response: requests.Response, request_summary: Optional[str] = None):
+    #     """旧版兼容方法：请求/响应已由 client 自动记录，本方法仅记录备注。"""
+    #     if request_summary:
+    #         self.log(f"请求: {request_summary}", COLOR_GREEN)
+
+    # def log_request_response(
+    #     self,
+    #     method: str,
+    #     url: str,
+    #     response: requests.Response,
+    #     request_body: Any = None,
+    #     request_headers: Optional[Dict[str, str]] = None,
+    #     note: Optional[str] = None,
+    # ):
+    #     """把一次完整 HTTP 请求/响应输出到日志。
+
+    #     请求和响应均由 Session 的 send 包装器自动记录，本方法只记录备注。
+    #     """
+    #     if note:
+    #         self.log(f"备注: {note}", COLOR_GREEN)
+
+    def _format_body(self, body: Any) -> str:
+        """将字符串/对象格式化为可读文本，过长时自动截断。"""
+        text = str(body)
+        if len(text) > 2000:
+            text = text[:2000] + "\n... (内容已截断)"
+        return text
+
+    @staticmethod
+    def _normalize_color(color: str) -> str:
+        """把常见颜色名映射到十六进制，兼容 LLM 生成的 color='green' 等写法。"""
+        if not color:
+            return COLOR_BLACK
+        c = str(color).strip().lower()
+        mapping = {
+            "black": COLOR_BLACK,
+            "green": COLOR_GREEN,
+            "blue": COLOR_BLUE,
+            "tan": COLOR_TAN,
+            "yellow": COLOR_TAN,
+            "red": COLOR_RED,
+            "error": COLOR_RED,
+            "request": COLOR_GREEN,
+            "response": COLOR_BLUE,
+            "stream": COLOR_TAN,
+            "llm": COLOR_TAN,
+        }
+        if c in mapping:
+            return mapping[c]
+        return color
+
+    def clear_log(self):
+        """清空日志框内容。"""
+        self.log_emitter.clear_log.emit()
+
+    # ------------------------------------------------------------------
+    # 环境清理
+    # ------------------------------------------------------------------
+    def clear_client(self):
+        """重置全局 client 对象（清除 cookies、headers 等状态）。"""
+        self.client = requests.Session()
+        self._wrap_client_send()
+
+    def close_client_connections(self):
+        """关闭底层连接池中的所有活跃连接，用于强制中断卡住的 HTTP 请求。"""
+        for adapter in self.client.adapters.values():
+            adapter.close()
+
+    def clear_globals(self):
+        """清理 exec 运行时的用户全局变量。"""
+        self.globals_vars.clear()
+
+    def clear_all(self):
+        """一键清理 client、全局变量、日志框。"""
+        self.clear_exec_env()
+        self.clear_log()
+        self.log("环境已清理")
+
+    def clear_exec_env(self):
+        """只清理执行环境（client、全局变量），不清理日志框。"""
+        self.clear_client()
+        self.clear_globals()
+        self.log("执行环境已清理（client 和全局变量已重置，日志保留）")
+
+    # ------------------------------------------------------------------
+    # exec 辅助
+    # ------------------------------------------------------------------
+    def build_globals(self) -> Dict[str, Any]:
+        """构造 exec(code, globals) 时使用的 globals 字典。"""
+
+        def safe_exit(code=0):
+            raise SafeExit(
+                f"代码调用了 exit({code})，在测试环境中 exit 不可用。"
+                f"如需停止执行，请删除 exit() 调用。"
+            )
+
+        g = {
+            "__builtins__": __builtins__,
+            "broker": self,
+            "client": self.client,
+            "config": self.config,
+            "log": self.log,
+            "log_raw": self.log_raw,
+            "log_stream": self.log_stream,
+            "log_json": self.log_json,
+            # "log_request": self.log_request,
+            # "log_response": self.log_response,
+            # "log_request_response": self.log_request_response,
+            "exit": safe_exit,
+            "quit": safe_exit,
+            "COLOR_BLACK": COLOR_BLACK,
+            "COLOR_GREEN": COLOR_GREEN,
+            "COLOR_BLUE": COLOR_BLUE,
+            "COLOR_TAN": COLOR_TAN,
+            "COLOR_RED": COLOR_RED,
+            "COLOR_GRAY": COLOR_GRAY,
+        }
+        g.update(self.globals_vars)
+        return g
+
+    def exec_code(self, code: str) -> Any:
+        """在线程中调用此方法执行代码，并返回 exec 的结果。"""
+        self.log("=" * 40)
+        self.log("开始执行生成的 Python 代码")
+        self.log("=" * 40)
+
+        g = self.build_globals()
+        result = None
+        try:
+            result = exec(code, g)
+        except SafeExit as e:
+            self.log(str(e), COLOR_RED)
+        except SystemExit as e:
+            code_val = e.code if e.code is not None else ""
+            self.log(f"执行被 exit({code_val}) 中断（建议删除代码中的 exit 调用）", COLOR_RED)
+        except KeyboardInterrupt:
+            self.log("执行被用户中断", COLOR_RED)
+            raise
+        except Exception as e:
+            tb = traceback.format_exc()
+            self.log(f"执行出错: {e}", COLOR_RED)
+            self.log(tb, COLOR_RED)
+            raise
+        finally:
+            preserved = {
+                "__builtins__", "broker", "client", "config",
+                "log", "log_raw", "log_stream", "log_json",
+                # "log_request", "log_response", "log_request_response",
+                "COLOR_BLACK", "COLOR_GREEN", "COLOR_BLUE", "COLOR_TAN", "COLOR_RED", "COLOR_GRAY",
+            }
+            for key, value in g.items():
+                if key not in preserved:
+                    self.globals_vars[key] = value
+            self.log("=" * 40)
+            self.log("代码执行结束")
+            self.log("=" * 40)
+        return result