From c2c9b552e8cdda8c06663569a4c7196489638a58 Mon Sep 17 00:00:00 2001
From: iqudoo <iqudoo@qq.com>
Date: Sun, 24 May 2026 22:34:41 +0800
Subject: [PATCH] fix

---
 src/App.vue | 3529 +++++++++++----------------------------------------
 1 file changed, 750 insertions(+), 2779 deletions(-)

diff --git a/src/App.vue b/src/App.vue
index 007337b..fbe95ba 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -6,138 +6,171 @@
     element-loading-background="rgba(255, 255, 255, 1)"
   >
     <el-header v-if="isMobile" class="mobile-header">
-      <div class="menu-toggle" @click="toggleMenu">
-        <el-button type="default"> 菜单 </el-button>
-      </div>
+      <el-button :icon="Menu" circle text class="menu-toggle-btn" @click="toggleMenu" />
       <h2>API 文档中心</h2>
+      <span class="mobile-header-spacer" />
     </el-header>
 
     <el-aside
-      :width="isMobile ? '100%' : '300px'"
+      :width="isMobile ? '100%' : '280px'"
       class="sidebar"
       v-show="(!isMobile || (isMobile && showMenu)) && !loadError"
     >
-      <!-- 手机端顶部关闭按钮 -->
-      <el-menu class="menu-vertical hide-scrollbar">
-        <div class="mobile-sidebar-header">
-          <h2 class="mobile-sidebar-title">API 文档中心</h2>
-          <el-button
-            type="default"
-            :icon="Close"
-            circle
-            class="mobile-sidebar-close-btn"
-            @click="toggleMenu"
-            v-if="isMobile"
-          />
-        </div>
-        <el-input
-          placeholder="搜索接口"
-          v-model="searchQuery"
-          clearable
-          class="search-input"
-          :disabled="loading || !!loadError"
-        />
-        <!-- 错误状态 -->
-        <div v-if="loadError" class="sidebar-error">
-          <el-empty description="加载失败" :image-size="100">
-            <el-button type="primary" size="small" @click="location.reload()"
-              >重新加载</el-button
-            >
-          </el-empty>
-        </div>
-
-        <!-- 正常内容 -->
-        <template v-else>
-          <!-- 返回按钮 -->
-          <div v-if="currentPath.length > 0" class="breadcrumb-nav">
-            <div class="breadcrumb-buttons">
-              <el-button link @click="goBack" class="breadcrumb-button">
-                <span style="margin-right: 5px">←</span> 返回上一级
-              </el-button>
-              <el-button link @click="goHome" class="breadcrumb-button">
-                <span style="margin-right: 5px">🏠</span> 回到根目录
-              </el-button>
-            </div>
-            <div class="breadcrumb-path">
-              <span
-                class="breadcrumb-item breadcrumb-clickable breadcrumb-home"
-                @click="goHome"
-              >
-                🏠 根目录
-              </span>
-              <span v-if="currentPath.length > 0" class="breadcrumb-separator"> / </span>
-              <span
-                v-for="(path, index) in currentPath"
-                :key="index"
-                class="breadcrumb-item"
-                @click="navigateToPath(index)"
-                :class="{ 'breadcrumb-clickable': index < currentPath.length - 1 }"
-              >
-                {{ path }}
-                <span v-if="index < currentPath.length - 1"> / </span>
+      <div class="sidebar-inner">
+        <div class="sidebar-header">
+          <div class="sidebar-brand">
+            <el-icon class="brand-icon"><Document /></el-icon>
+            <div class="brand-text">
+              <span class="brand-title">API 文档中心</span>
+              <span v-if="!loading && !loadError" class="brand-subtitle">
+                共 {{ apis.length }} 个接口
               </span>
             </div>
           </div>
-          <el-empty
-            v-if="
-              !loading &&
-              !loadError &&
-              currentLevelNodes.length === 0 &&
-              currentLevelApis.length === 0
-            "
-            description="没有找到相关接口"
+          <el-button
+            v-if="isMobile"
+            :icon="Close"
+            circle
+            text
+            class="sidebar-close-btn"
+            @click="toggleMenu"
           />
-          <!-- 显示当前层级的内容 -->
-          <template v-for="node in currentLevelNodes" :key="node.key">
-            <!-- 分组：点击进入下一级（有子节点或只有API的分组） -->
-            <el-menu-item
+        </div>
+
+        <div class="sidebar-search">
+          <el-input
+            placeholder="搜索接口..."
+            v-model="searchQuery"
+            clearable
+            :prefix-icon="Search"
+            :disabled="loading || !!loadError"
+          />
+        </div>
+
+        <div class="sidebar-content">
+          <div v-if="loadError" class="sidebar-error">
+            <el-empty description="加载失败" :image-size="80">
+              <el-button type="primary" size="small" @click="location.reload()">
+                重新加载
+              </el-button>
+            </el-empty>
+          </div>
+
+          <template v-else>
+            <div v-if="currentPath.length > 0" class="breadcrumb-nav">
+              <div class="breadcrumb-toolbar">
+                <el-button link :icon="ArrowLeft" @click="goBack" class="breadcrumb-btn">
+                  返回
+                </el-button>
+                <el-button link :icon="HomeFilled" @click="goHome" class="breadcrumb-btn">
+                  根目录
+                </el-button>
+              </div>
+              <div class="breadcrumb-path">
+                <span class="breadcrumb-tag breadcrumb-clickable" @click="goHome">根目录</span>
+                <template v-for="(path, index) in currentPath" :key="index">
+                  <el-icon class="breadcrumb-chevron"><ArrowRight /></el-icon>
+                  <span
+                    class="breadcrumb-tag"
+                    :class="{
+                      'breadcrumb-clickable': index < currentPath.length - 1,
+                      'breadcrumb-current': index === currentPath.length - 1,
+                    }"
+                    @click="index < currentPath.length - 1 && navigateToPath(index)"
+                  >
+                    {{ path }}
+                  </span>
+                </template>
+              </div>
+            </div>
+
+            <el-empty
               v-if="
-                !node.isUngrouped && (node.children.length > 0 || node.apis.length > 0)
+                !loading &&
+                !loadError &&
+                currentLevelNodes.length === 0 &&
+                currentLevelApis.length === 0
               "
-              :index="node.key"
-              @click="enterGroup(node)"
-              class="group-item"
-              :disabled="loading"
+              description="没有找到相关接口"
+              :image-size="64"
+              class="sidebar-empty"
+            />
+
+            <el-menu
+              v-else
+              class="menu-vertical"
+              :default-active="activeMenuIndex"
             >
-              <span class="folder-icon">{{
-                node.children.length > 0 ? "📁" : "📂"
-              }}</span>
-              <span>{{ node.displayName }}</span>
-              <span class="arrow-icon">→</span>
-            </el-menu-item>
-            <!-- API项：点击查看详情（未分组的API） -->
-            <el-menu-item
-              v-else-if="node.isUngrouped"
-              :index="node.key"
-              @click="
-                goToApi(node.apis[0]);
-                isMobile && toggleMenu();
-              "
-              :disabled="loading"
-            >
-              {{ node.displayName }}
-            </el-menu-item>
+              <template v-for="node in currentLevelNodes" :key="node.key">
+                <el-menu-item
+                  v-if="
+                    !node.isUngrouped && (node.children.length > 0 || node.apis.length > 0)
+                  "
+                  :index="node.key"
+                  @click="enterGroup(node)"
+                  class="menu-folder-item"
+                  :disabled="loading"
+                >
+                  <div class="menu-item-inner">
+                    <el-icon class="menu-item-icon folder"><Folder /></el-icon>
+                    <span class="menu-item-label">{{ node.displayName }}</span>
+                    <span class="menu-item-count">{{ getNodeApiCount(node) }}</span>
+                    <el-icon class="menu-item-arrow"><ArrowRight /></el-icon>
+                  </div>
+                </el-menu-item>
+
+                <el-menu-item
+                  v-else-if="node.isUngrouped"
+                  :index="node.key"
+                  @click="
+                    goToApi(node.apis[0]);
+                    isMobile && toggleMenu();
+                  "
+                  class="menu-api-item"
+                  :disabled="loading"
+                >
+                  <div class="menu-item-inner">
+                    <el-icon class="menu-item-icon api"><Document /></el-icon>
+                    <span class="menu-item-label">{{ node.displayName }}</span>
+                  </div>
+                </el-menu-item>
+              </template>
+
+              <template v-if="currentLevelApis.length > 0">
+                <el-menu-item
+                  v-if="currentLevelNodes.length > 0"
+                  index="__section_apis__"
+                  disabled
+                  class="menu-section-item"
+                >
+                  <span class="menu-section-label">接口</span>
+                </el-menu-item>
+                <el-menu-item
+                  v-for="api in currentLevelApis"
+                  :key="api.uniqueId"
+                  :index="api.uniqueId"
+                  @click="
+                    goToApi(api);
+                    isMobile && toggleMenu();
+                  "
+                  class="menu-api-item"
+                  :disabled="loading"
+                >
+                  <div class="menu-item-inner">
+                    <el-icon class="menu-item-icon api"><Document /></el-icon>
+                    <span class="menu-item-label">{{
+                      getCurrentNodeApiDisplayName(api)
+                    }}</span>
+                  </div>
+                </el-menu-item>
+              </template>
+            </el-menu>
           </template>
-          <!-- 显示当前节点下的API（当进入只有API的节点时） -->
-          <template v-if="currentLevelApis.length > 0">
-            <el-menu-item
-              v-for="api in currentLevelApis"
-              :key="api.uniqueId"
-              :index="api.uniqueId"
-              @click="
-                goToApi(api);
-                isMobile && toggleMenu();
-              "
-              :disabled="loading"
-            >
-              {{ getCurrentNodeApiDisplayName(api) }}
-            </el-menu-item>
-          </template>
-        </template>
-      </el-menu>
+        </div>
+      </div>
     </el-aside>
 
-    <el-main>
+    <el-main class="main-content">
       <!-- 接口列表加载失败时全屏显示错误 -->
       <div v-if="loadError" class="error-container fullscreen-error">
         <el-result icon="error" title="加载失败" :sub-title="loadError">
@@ -147,8 +180,14 @@
         </el-result>
       </div>
 
-      <!-- 主内容标签页 -->
-      <el-tabs v-else v-model="activeTab" class="main-tabs">
+      <template v-else>
+        <div class="main-toolbar">
+          <el-button type="primary" :icon="Download" @click="showExportDrawer = true">
+            导出文档
+          </el-button>
+        </div>
+
+        <el-tabs v-model="activeTab" class="main-tabs">
         <!-- API文档tab -->
         <el-tab-pane label="API 文档" name="docs">
           <!-- README引导页 -->
@@ -168,9 +207,9 @@
                 <h3>1. 浏览接口</h3>
                 <p>在左侧菜单中浏览所有可用的接口，接口按模块分组显示。</p>
                 <ul>
-                  <li>点击文件夹图标可以进入下一级目录</li>
-                  <li>点击接口名称可以查看详细的接口文档</li>
-                  <li>使用搜索框可以快速查找接口</li>
+                  <li>点击文件夹进入下一级目录</li>
+                  <li>点击接口名称查看详细文档</li>
+                  <li>使用搜索框快速查找接口</li>
                 </ul>
               </div>
 
@@ -186,7 +225,7 @@
 
               <div class="readme-section">
                 <h3>3. 导出文档</h3>
-                <p>切换到"导出文档"标签页，可以：</p>
+                <p>点击右上角「导出文档」按钮，可以：</p>
                 <ul>
                   <li>一键导出所有接口文档</li>
                   <li>按需选择接口进行导出</li>
@@ -267,14 +306,9 @@
             <div v-if="apiDetail">
               <h3>请求参数</h3>
               <div v-if="apiDetail?.paramModel">
-                <div
-                  style="margin-bottom: 60px"
-                  v-if="getAllModels(apiDetail.paramModel).length <= 0"
-                >
-                  <div :id="'model-' + apiDetail.paramModel.simpleName">
-                    {{ apiDetail.paramModel.simpleName }}
-                  </div>
-                </div>
+                <p v-if="apiDetail.paramModel.basicProperty" class="basic-type-display">
+                  类型：{{ getFullTypeName(apiDetail.paramModel) }}
+                </p>
                 <div
                   v-for="model in getAllModels(apiDetail.paramModel)"
                   :key="model.simpleName"
@@ -452,14 +486,9 @@
 
               <h3>请求响应</h3>
               <div v-if="apiDetail?.responseModel">
-                <div
-                  style="margin-bottom: 60px"
-                  v-if="getAllModels(apiDetail.responseModel).length <= 0"
-                >
-                  <div :id="'model-' + apiDetail.responseModel.simpleName">
-                    {{ apiDetail.responseModel.simpleName }}
-                  </div>
-                </div>
+                <p v-if="apiDetail.responseModel.basicProperty" class="basic-type-display">
+                  类型：{{ getFullTypeName(apiDetail.responseModel) }}
+                </p>
                 <div
                   v-for="model in getAllModels(apiDetail.responseModel)"
                   :key="model.simpleName"
@@ -678,425 +707,112 @@
           </div>
         </el-tab-pane>
 
-        <!-- 调试模块tab -->
-        <!-- <el-tab-pane label="调试工具" name="debug">
-          <div class="debug-module">
-            <div class="debug-layout">
-              <div class="debug-request-panel">
-                <div class="debug-panel-header">
-                  <span class="panel-title">请求</span>
-                </div>
-                <div class="debug-panel-content">
-                  <div class="debug-url-section">
-                    <div class="debug-label">接口地址</div>
-                    <el-input
-                      v-model="debugConfig.apiUrl"
-                      placeholder="https://api.example.com"
-                      class="debug-url-input"
-                    >
-                      <template #prepend>
-                        <el-select v-model="debugMethod" style="width: 100px" disabled>
-                          <el-option label="POST" value="POST" />
-                        </el-select>
-                      </template>
-                    </el-input>
-                  </div>
-
-                  <div class="debug-form-section">
-                    <el-form :model="debugForm" ref="debugFormRef" label-position="top">
-                      <el-form-item label="调试接口">
-                        <el-input
-                          :value="getCurrentApiAction()"
-                          placeholder="请从左侧接口列表选择接口"
-                          readonly
-                          disabled
-                        >
-                          <template #prepend>
-                            <el-icon><Document /></el-icon>
-                          </template>
-                        </el-input>
-                      </el-form-item>
-
-                      <el-form-item label="Token" prop="token">
-                        <el-input
-                          v-model="debugForm.token"
-                          placeholder="输入token，可使用 {{变量名}}"
-                        />
-                      </el-form-item>
-
-                      <el-collapse
-                        v-model="variableCollapseActive"
-                        class="debug-collapse"
-                      >
-                        <el-collapse-item name="variables" title="变量管理">
-                          <div class="variable-section">
-                            <el-button
-                              type="primary"
-                              size="small"
-                              @click="openAddVariableDialog"
-                              style="margin-bottom: 10px"
-                            >
-                              + 添加变量
-                            </el-button>
-                            <el-table
-                              :data="debugVariables"
-                              size="small"
-                              :show-header="debugVariables.length > 0"
-                            >
-                              <el-table-column prop="name" label="变量名" width="120" />
-                              <el-table-column prop="value" label="变量值" />
-                              <el-table-column label="操作" width="100">
-                                <template #default="scope">
-                                  <el-button
-                                    type="primary"
-                                    size="small"
-                                    link
-                                    @click="editVariable(scope.row, scope.$index)"
-                                  >
-                                    编辑
-                                  </el-button>
-                                  <el-button
-                                    type="danger"
-                                    size="small"
-                                    link
-                                    @click="deleteVariable(scope.$index)"
-                                  >
-                                    删除
-                                  </el-button>
-                                </template>
-                              </el-table-column>
-                            </el-table>
-                          </div>
-                        </el-collapse-item>
-                      </el-collapse>
-
-                      <el-collapse
-                        v-model="paramsCollapseActive"
-                        class="debug-collapse"
-                        v-if="debugFormParams.length > 0"
-                      >
-                        <el-collapse-item name="params">
-                          <template #title>
-                            <span>参数</span>
-                            <el-radio-group
-                              v-model="paramInputMode"
-                              size="small"
-                              style="margin-left: 16px"
-                              @change="onParamModeChange"
-                              @click.stop
-                            >
-                              <el-radio-button value="form">表单</el-radio-button>
-                              <el-radio-button value="json">JSON</el-radio-button>
-                            </el-radio-group>
-                          </template>
-
-                          <template v-if="paramInputMode === 'form'">
-                            <el-form-item
-                              v-for="param in debugFormParams"
-                              :key="param.name"
-                              :label="param.name"
-                              :prop="'params.' + param.name"
-                              :rules="param.rules"
-                              class="debug-param-item"
-                            >
-                              <el-input
-                                v-if="!isComplexType(param.field)"
-                                v-model="debugForm.params[param.name]"
-                                :placeholder="
-                                  param.desc ||
-                                  '输入' + param.name + '，可使用 {{变量名}}'
-                                "
-                              />
-                              <el-input
-                                v-else
-                                v-model="debugForm.params[param.name]"
-                                :placeholder="
-                                  param.desc || '输入JSON格式，可使用 {{变量名}}'
-                                "
-                                type="textarea"
-                                :rows="4"
-                              />
-                              <div
-                                class="param-desc"
-                                v-if="
-                                  param.desc ||
-                                  (param.enumInfo && param.enumInfo.properties)
-                                "
-                              >
-                                <div v-if="param.desc" class="param-desc-text">
-                                  {{ param.desc }}
-                                </div>
-                                <div
-                                  v-if="param.enumInfo && param.enumInfo.properties"
-                                  class="param-desc-text"
-                                >
-                                  枚举值：
-                                  <span
-                                    v-for="(item, index) in param.enumInfo.properties"
-                                    :key="index"
-                                  >
-                                    {{ item.desc }}({{ item.value }})
-                                    <span
-                                      v-if="index < param.enumInfo.properties.length - 1"
-                                      >、</span
-                                    >
-                                  </span>
-                                </div>
-                              </div>
-                            </el-form-item>
-                          </template>
-
-                          <template v-else>
-                            <div class="json-mode-container">
-                              <div class="json-mode-header">
-                                <span class="json-mode-tip"
-                                  >编辑JSON参数，可使用变量模板</span
-                                >
-                                <el-button
-                                  type="primary"
-                                  size="small"
-                                  link
-                                  @click="formatJsonParams"
-                                >
-                                  格式化
-                                </el-button>
-                                <el-button
-                                  type="primary"
-                                  size="small"
-                                  link
-                                  @click="resetJsonParams"
-                                >
-                                  重置示例
-                                </el-button>
-                              </div>
-                              <el-input
-                                v-model="debugForm.jsonParams"
-                                type="textarea"
-                                :rows="15"
-                                placeholder="请输入JSON格式的参数"
-                                class="json-params-input"
-                                @blur="validateJsonParams"
-                              />
-                              <div v-if="jsonParamsError" class="json-params-error">
-                                {{ jsonParamsError }}
-                              </div>
-                            </div>
-                          </template>
-                        </el-collapse-item>
-                      </el-collapse>
-
-                      <el-form-item>
-                        <el-button
-                          type="primary"
-                          @click="handleDebug"
-                          :loading="debugging"
-                          class="debug-send-button"
-                        >
-                          <span v-if="!debugging">发送</span>
-                          <span v-else>发送中...</span>
-                        </el-button>
-                        <el-button @click="resetDebugForm">重置</el-button>
-                      </el-form-item>
-                    </el-form>
-                  </div>
-                </div>
-              </div>
-
-              <div class="debug-response-panel">
-                <div class="debug-panel-header">
-                  <span class="panel-title">响应</span>
-                  <span v-if="debugResult && debugResult.time" class="response-time">
-                    耗时: {{ debugResult.time }}ms
-                  </span>
-                </div>
-                <div class="debug-panel-content">
-                  <div v-if="!debugResult" class="debug-empty-state">
-                    <el-empty description="点击发送按钮发送请求" :image-size="100" />
-                  </div>
-                  <div v-else>
-                    <el-tabs v-model="debugResultTab" class="debug-result-tabs">
-                      <el-tab-pane label="响应体" name="response">
-                        <div class="debug-result-container">
-                          <div class="debug-result-header">
-                            <span
-                              class="result-status"
-                              :class="getStatusClass(debugResult.status)"
-                            >
-                              状态: {{ debugResult.status || "N/A" }}
-                            </span>
-                          </div>
-                          <pre class="debug-result-content">{{
-                            formatDebugResult(debugResult.response)
-                          }}</pre>
-                        </div>
-                      </el-tab-pane>
-                      <el-tab-pane label="日志" name="log">
-                        <div class="debug-log-container">
-                          <div
-                            v-for="(log, index) in debugLogs"
-                            :key="index"
-                            class="log-item"
-                            :class="log.type.toLowerCase()"
-                          >
-                            <span class="log-time">{{ log.time }}</span>
-                            <span class="log-type">[{{ log.type }}]</span>
-                            <span class="log-message">{{ log.message }}</span>
-                          </div>
-                        </div>
-                      </el-tab-pane>
-                    </el-tabs>
-                  </div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </el-tab-pane> -->
-
-        <el-tab-pane label="导出文档" name="export">
-          <!-- 导出模块 -->
-          <div class="export-module">
-            <div class="export-module-header">
-              <h2>导出接口文档</h2>
-              <p class="export-description">
-                导出接口文档为 Markdown 格式，支持导出全部或按需选择
-              </p>
-            </div>
-
-            <!-- 快速导出全部 -->
-            <div class="export-quick-actions">
-              <el-card shadow="hover" class="quick-export-card">
-                <template #header>
-                  <div class="card-header">
-                    <span>快速导出</span>
-                  </div>
-                </template>
-                <div class="quick-export-content">
-                  <p class="quick-export-desc">一键导出所有接口文档</p>
-                  <el-button
-                    type="primary"
-                    size="large"
-                    @click="downloadApiDocumentation"
-                    :loading="downloading"
-                  >
-                    {{ downloading ? "下载中..." : "下载全部接口文档" }}
-                  </el-button>
-                </div>
-              </el-card>
-            </div>
-
-            <!-- 按需导出 -->
-            <div class="export-content">
-              <div class="export-section-title">
-                <div class="card-header">
-                  <span>按需导出</span>
-                </div>
-                <p class="section-desc">选择需要导出的接口，生成自定义文档</p>
-              </div>
-              <div class="export-select-header">
-                <el-input
-                  v-model="exportSearchQuery"
-                  placeholder="搜索接口"
-                  clearable
-                  style="margin-bottom: 15px"
-                  size="large"
-                />
-                <div class="select-actions">
-                  <el-button type="primary" @click="selectAllExportApis">全选</el-button>
-                  <el-button @click="deselectAllExportApis">取消全选</el-button>
-                  <span class="selected-count"
-                    >已选择: {{ selectedApiIds.length }} / {{ totalExportApiCount }}</span
-                  >
-                </div>
-              </div>
-              <div class="export-api-list">
-                <el-tree
-                  ref="exportTreeRef"
-                  :data="exportTreeData"
-                  :props="exportTreeProps"
-                  show-checkbox
-                  node-key="id"
-                  :default-expand-all="false"
-                  :filter-node-method="filterExportNode"
-                  @check="handleExportTreeCheck"
-                >
-                  <template #default="{ node, data }">
-                    <span class="export-tree-node">
-                      <span v-if="data.isApi" class="api-icon">📄</span>
-                      <span v-else class="folder-icon">📁</span>
-                      <span class="node-label">{{ node.label }}</span>
-                    </span>
-                  </template>
-                </el-tree>
-              </div>
-              <div class="export-actions">
-                <el-button
-                  type="primary"
-                  size="large"
-                  @click="handleExportSelected"
-                  :loading="downloading"
-                  :disabled="selectedApiIds.length === 0"
-                >
-                  {{ downloading ? "导出中..." : "导出文档" }}
-                </el-button>
-              </div>
-            </div>
-          </div>
-        </el-tab-pane>
       </el-tabs>
+      </template>
     </el-main>
   </el-container>
 
-  <!-- 添加/编辑变量对话框 -->
-  <el-dialog
-    v-model="showAddVariableDialog"
-    :title="editingVariableIndex >= 0 ? '编辑变量' : '添加变量'"
-    width="500px"
+  <el-drawer
+    v-model="showExportDrawer"
+    title="导出文档"
+    direction="rtl"
+    size="480px"
+    class="export-drawer"
   >
-    <el-form :model="variableForm" label-width="80px" ref="variableFormRef">
-      <el-form-item
-        label="变量名"
-        prop="name"
-        :rules="[{ required: true, message: '请输入变量名', trigger: 'blur' }]"
-      >
-        <el-input
-          v-model="variableForm.name"
-          placeholder="请输入变量名，例如: token"
-          :disabled="editingVariableIndex >= 0"
-        />
-      </el-form-item>
-      <el-form-item
-        label="变量值"
-        prop="value"
-        :rules="[{ required: true, message: '请输入变量值', trigger: 'blur' }]"
-      >
-        <el-input
-          v-model="variableForm.value"
-          type="textarea"
-          :rows="3"
-          placeholder="请输入变量值"
-        />
-      </el-form-item>
-      <el-form-item label="说明" prop="desc">
-        <el-input
-          v-model="variableForm.desc"
-          type="textarea"
-          :rows="2"
-          placeholder="请输入变量说明（可选）"
-        />
-      </el-form-item>
-    </el-form>
-    <template #footer>
-      <el-button @click="showAddVariableDialog = false">取消</el-button>
-      <el-button type="primary" @click="saveVariable">确定</el-button>
-    </template>
-  </el-dialog>
+    <div class="export-module">
+      <p class="export-description">
+        导出接口文档为 Markdown 格式，支持导出全部或按需选择
+      </p>
+
+      <el-card shadow="never" class="quick-export-card">
+        <template #header>
+          <span class="card-header">快速导出</span>
+        </template>
+        <div class="quick-export-content">
+          <p class="quick-export-desc">一键导出所有接口文档</p>
+          <el-button
+            type="primary"
+            @click="downloadApiDocumentation"
+            :loading="downloading"
+            style="width: 100%"
+          >
+            {{ downloading ? "下载中..." : "下载全部接口文档" }}
+          </el-button>
+        </div>
+      </el-card>
+
+      <div class="export-content">
+        <div class="export-section-title">
+          <span class="card-header">按需导出</span>
+          <p class="section-desc">选择需要导出的接口，生成自定义文档</p>
+        </div>
+        <div class="export-select-header">
+          <el-input
+            v-model="exportSearchQuery"
+            placeholder="搜索接口"
+            clearable
+            :prefix-icon="Search"
+          />
+          <div class="select-actions">
+            <el-button type="primary" @click="selectAllExportApis">全选</el-button>
+            <el-button @click="deselectAllExportApis">取消全选</el-button>
+            <span class="selected-count">
+              已选择: {{ selectedApiIds.length }} / {{ totalExportApiCount }}
+            </span>
+          </div>
+        </div>
+        <div class="export-api-list">
+          <el-tree
+            ref="exportTreeRef"
+            :data="exportTreeData"
+            :props="exportTreeProps"
+            show-checkbox
+            node-key="id"
+            :default-expand-all="false"
+            :filter-node-method="filterExportNode"
+            @check="handleExportTreeCheck"
+          >
+            <template #default="{ node, data }">
+              <span class="export-tree-node">
+                <el-icon v-if="data.isApi" class="api-icon"><Document /></el-icon>
+                <el-icon v-else class="folder-icon"><Folder /></el-icon>
+                <span class="node-label">{{ node.label }}</span>
+              </span>
+            </template>
+          </el-tree>
+        </div>
+        <div class="export-actions">
+          <el-button
+            type="primary"
+            @click="handleExportSelected"
+            :loading="downloading"
+            :disabled="selectedApiIds.length === 0"
+            style="width: 100%"
+          >
+            {{ downloading ? "导出中..." : "导出所选文档" }}
+          </el-button>
+        </div>
+      </div>
+    </div>
+  </el-drawer>
 </template>
 
 <script setup>
 import { ref, onMounted, computed, watch, defineComponent, h } from "vue";
 import axios from "axios";
 import { ElMessage } from "element-plus";
-import { DocumentCopy, Close, Document } from "@element-plus/icons-vue";
+import { DocumentCopy, Close, Document, Folder, ArrowRight, ArrowLeft, HomeFilled, Search, Download, Menu } from "@element-plus/icons-vue";
+
+const activeMenuIndex = computed(() => currentApi.value?.uniqueId ?? "");
+
+// 统计节点下接口总数（含子目录）
+const getNodeApiCount = (node) => {
+  let count = node.apis?.length || 0;
+  (node.children || []).forEach((child) => {
+    count += getNodeApiCount(child);
+  });
+  return count;
+};
 
 // 递归菜单节点组件（用于处理无限级嵌套）
 const MenuTreeNode = defineComponent({
@@ -1191,39 +907,8 @@ const exportTreeProps = {
   label: "label",
 };
 
-// 调试模块相关状态
-// 从环境变量获取 API 地址
 const hostUrl = ref(import.meta.env.VITE_API_URL || "/api");
-
-const debugConfig = ref({
-  apiUrl: hostUrl.value, // 默认使用环境变量中的 hostUrl
-});
-const debugVariables = ref([]);
-const showAddVariableDialog = ref(false);
-const variableForm = ref({
-  name: "",
-  value: "",
-  desc: "",
-});
-const editingVariableIndex = ref(-1);
-const debugForm = ref({
-  selectedApi: null,
-  token: "",
-  params: {},
-  jsonParams: "", // JSON模式的参数
-});
-const debugFormRef = ref(null);
-const debugFormParams = ref([]);
-const debugging = ref(false);
-const debugResult = ref(null);
-const debugResultTab = ref("response");
-const debugLogs = ref([]);
-const selectedApiDetail = ref(null);
-const debugMethod = ref("POST"); // 请求方法
-const variableCollapseActive = ref([]); // 变量折叠面板状态
-const paramsCollapseActive = ref(["params"]); // 参数折叠面板状态
-const paramInputMode = ref("form"); // 参数输入模式: form(表单) 或 json(JSON)
-const jsonParamsError = ref(""); // JSON参数验证错误
+const showExportDrawer = ref(false);
 
 // 监听搜索，如果有搜索则自动返回根级别显示所有匹配结果
 watch(searchQuery, (newVal) => {
@@ -1234,21 +919,10 @@ watch(searchQuery, (newVal) => {
   }
 });
 
-// 监听变量对话框关闭
-watch(showAddVariableDialog, (newVal) => {
-  if (!newVal) {
-    // 对话框关闭时重置表单
-    resetVariableForm();
-  }
-});
-
 // IndexedDB 缓存工具
 const DB_NAME = "api-docs-cache";
-const DB_VERSION = 4; // 升级版本号以支持接口调试缓存（兼容已有版本4的数据库）
+const DB_VERSION = 4;
 const STORE_NAME = "api-list";
-const DEBUG_CONFIG_STORE = "debug-config";
-const DEBUG_VARIABLES_STORE = "debug-variables";
-const DEBUG_API_CACHE_STORE = "debug-api-cache"; // 接口调试缓存
 
 // 初始化 IndexedDB（支持版本兼容）
 const initDB = () => {
@@ -1281,19 +955,9 @@ const initDB = () => {
     request.onupgradeneeded = (event) => {
       const db = event.target.result;
 
-      // 创建所有需要的 object stores（只在需要时创建）
       if (!db.objectStoreNames.contains(STORE_NAME)) {
         db.createObjectStore(STORE_NAME);
       }
-      if (!db.objectStoreNames.contains(DEBUG_CONFIG_STORE)) {
-        db.createObjectStore(DEBUG_CONFIG_STORE);
-      }
-      if (!db.objectStoreNames.contains(DEBUG_VARIABLES_STORE)) {
-        db.createObjectStore(DEBUG_VARIABLES_STORE);
-      }
-      if (!db.objectStoreNames.contains(DEBUG_API_CACHE_STORE)) {
-        db.createObjectStore(DEBUG_API_CACHE_STORE);
-      }
     };
 
     request.onblocked = () => {
@@ -1302,25 +966,6 @@ const initDB = () => {
   });
 };
 
-// 检查并确保 object store 存在
-const ensureStoreExists = async (storeName) => {
-  try {
-    const db = await initDB();
-    if (!db.objectStoreNames.contains(storeName)) {
-      // Store 不存在，提示用户刷新页面
-      console.warn(
-        `Store ${storeName} does not exist. Please refresh the page to upgrade the database.`
-      );
-      ElMessage.warning("数据库需要升级，请刷新页面");
-      return null;
-    }
-    return db;
-  } catch (error) {
-    console.error("Failed to ensure store exists:", error);
-    return null;
-  }
-};
-
 // 从 IndexedDB 获取缓存的接口列表
 const getCachedApiList = async () => {
   try {
@@ -1395,1376 +1040,7 @@ const processApiList = (apiData) => {
   return expandedApis.sort((a, b) => a.action.localeCompare(b.action));
 };
 
-// ========== 调试模块相关函数 ==========
 
-// 保存调试配置到 IndexedDB（静默保存，不显示提示）
-const saveDebugConfig = async (showMessage = false) => {
-  try {
-    const db = await initDB();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([DEBUG_CONFIG_STORE], "readwrite");
-      const store = transaction.objectStore(DEBUG_CONFIG_STORE);
-      // 创建纯对象副本，避免响应式对象序列化问题
-      const configData = {
-        apiUrl: debugConfig.value.apiUrl || "",
-        token: debugForm.value.token || "", // 保存token
-      };
-      const request = store.put(configData, "config");
-      request.onsuccess = () => {
-        if (showMessage) {
-          ElMessage.success("配置已保存");
-        }
-        resolve();
-      };
-      request.onerror = () => reject(request.error);
-    });
-  } catch (error) {
-    console.error("Failed to save debug config:", error);
-    if (showMessage) {
-      ElMessage.error("保存配置失败");
-    }
-  }
-};
-
-// 从 IndexedDB 读取调试配置
-const loadDebugConfig = async () => {
-  try {
-    const db = await initDB();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([DEBUG_CONFIG_STORE], "readonly");
-      const store = transaction.objectStore(DEBUG_CONFIG_STORE);
-      const request = store.get("config");
-      request.onsuccess = () => {
-        if (request.result) {
-          debugConfig.value = {
-            apiUrl: request.result.apiUrl || hostUrl.value, // 如果没有配置，使用环境变量中的 hostUrl
-          };
-          // 加载token到debugForm
-          if (request.result.token) {
-            debugForm.value.token = request.result.token;
-          }
-        } else {
-          // 如果没有缓存配置，使用环境变量中的 hostUrl 作为默认值
-          debugConfig.value = {
-            apiUrl: hostUrl.value,
-          };
-        }
-        resolve(request.result || null);
-      };
-      request.onerror = () => reject(request.error);
-    });
-  } catch (error) {
-    console.error("Failed to load debug config:", error);
-    return null;
-  }
-};
-
-// 保存变量到 IndexedDB（静默保存，不显示提示）
-const saveDebugVariables = async (showMessage = false) => {
-  try {
-    const db = await initDB();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([DEBUG_VARIABLES_STORE], "readwrite");
-      const store = transaction.objectStore(DEBUG_VARIABLES_STORE);
-      // 使用 JSON 序列化创建纯对象副本，避免响应式对象序列化问题
-      const variablesData = JSON.parse(JSON.stringify(debugVariables.value));
-      const request = store.put(variablesData, "variables");
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  } catch (error) {
-    console.error("Failed to save debug variables:", error);
-    if (showMessage) {
-      ElMessage.error("保存变量失败");
-    }
-  }
-};
-
-// 从 IndexedDB 读取变量
-const loadDebugVariables = async () => {
-  try {
-    const db = await initDB();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([DEBUG_VARIABLES_STORE], "readonly");
-      const store = transaction.objectStore(DEBUG_VARIABLES_STORE);
-      const request = store.get("variables");
-      request.onsuccess = () => {
-        if (request.result) {
-          debugVariables.value = request.result;
-        }
-        resolve(request.result || []);
-      };
-      request.onerror = () => reject(request.error);
-    });
-  } catch (error) {
-    console.error("Failed to load debug variables:", error);
-    return [];
-  }
-};
-
-// 保存接口调试缓存到 IndexedDB
-const saveApiDebugCache = async (apiUniqueId, cacheData) => {
-  if (!apiUniqueId) return;
-
-  try {
-    const db = await initDB();
-    return new Promise((resolve) => {
-      try {
-        const transaction = db.transaction([DEBUG_API_CACHE_STORE], "readwrite");
-        const store = transaction.objectStore(DEBUG_API_CACHE_STORE);
-        // 使用 JSON 序列化创建纯对象副本，避免响应式对象序列化问题
-        const cleanCacheData = JSON.parse(JSON.stringify(cacheData));
-        const request = store.put(cleanCacheData, apiUniqueId);
-        request.onsuccess = () => resolve();
-        request.onerror = () => {
-          // Store 不存在或其他错误
-          console.warn("Failed to save API debug cache:", request.error);
-          resolve();
-        };
-      } catch (error) {
-        // Store 不存在或其他错误
-        if (
-          error.name === "NotFoundError" ||
-          error.message?.includes("object stores was not found")
-        ) {
-          console.warn(
-            "Store does not exist, please refresh the page to upgrade the database."
-          );
-          // 不显示提示，因为保存失败不影响主要功能
-        } else {
-          console.error("Failed to access store:", error);
-        }
-        resolve();
-      }
-    });
-  } catch (error) {
-    if (
-      error.name === "NotFoundError" ||
-      error.message?.includes("object stores was not found")
-    ) {
-      console.warn(
-        "Store does not exist, please refresh the page to upgrade the database."
-      );
-    } else {
-      console.error("Failed to save API debug cache:", error);
-    }
-  }
-};
-
-// 从 IndexedDB 读取接口调试缓存
-const loadApiDebugCache = async (apiUniqueId) => {
-  if (!apiUniqueId) return null;
-
-  try {
-    const db = await initDB();
-    return new Promise((resolve) => {
-      try {
-        const transaction = db.transaction([DEBUG_API_CACHE_STORE], "readonly");
-        const store = transaction.objectStore(DEBUG_API_CACHE_STORE);
-        const request = store.get(apiUniqueId);
-        request.onsuccess = () => {
-          resolve(request.result || null);
-        };
-        request.onerror = () => {
-          // Store 不存在或其他错误，返回 null
-          console.warn("Failed to load API debug cache:", request.error);
-          resolve(null);
-        };
-      } catch (error) {
-        // Store 不存在或其他错误
-        if (
-          error.name === "NotFoundError" ||
-          error.message?.includes("object stores was not found")
-        ) {
-          console.warn(
-            "Store does not exist, please refresh the page to upgrade the database."
-          );
-          ElMessage.warning("数据库需要升级，请刷新页面");
-        } else {
-          console.error("Failed to access store:", error);
-        }
-        resolve(null);
-      }
-    });
-  } catch (error) {
-    if (
-      error.name === "NotFoundError" ||
-      error.message?.includes("object stores was not found")
-    ) {
-      console.warn(
-        "Store does not exist, please refresh the page to upgrade the database."
-      );
-      ElMessage.warning("数据库需要升级，请刷新页面");
-    } else {
-      console.error("Failed to load API debug cache:", error);
-    }
-    return null;
-  }
-};
-
-// 保存变量
-const saveVariable = async () => {
-  if (!variableForm.value.name || !variableForm.value.value) {
-    ElMessage.warning("请填写变量名和变量值");
-    return;
-  }
-
-  // 检查变量名是否重复（编辑时排除当前项）
-  const existingIndex = debugVariables.value.findIndex(
-    (v, index) =>
-      v.name === variableForm.value.name && index !== editingVariableIndex.value
-  );
-  if (existingIndex >= 0) {
-    ElMessage.warning("变量名已存在");
-    return;
-  }
-
-  if (editingVariableIndex.value >= 0) {
-    // 编辑
-    debugVariables.value[editingVariableIndex.value] = { ...variableForm.value };
-    ElMessage.success("变量已更新");
-  } else {
-    // 新增
-    debugVariables.value.push({ ...variableForm.value });
-    ElMessage.success("变量已添加");
-  }
-
-  // 清除防抖定时器，立即保存
-  if (variablesSaveTimer) {
-    clearTimeout(variablesSaveTimer);
-    variablesSaveTimer = null;
-  }
-  await saveDebugVariables(false);
-  showAddVariableDialog.value = false;
-  resetVariableForm();
-};
-
-// 编辑变量
-const editVariable = (variable, index) => {
-  variableForm.value = { ...variable };
-  editingVariableIndex.value = index;
-  showAddVariableDialog.value = true;
-};
-
-// 删除变量
-const deleteVariable = async (index) => {
-  debugVariables.value.splice(index, 1);
-  // 清除防抖定时器，立即保存
-  if (variablesSaveTimer) {
-    clearTimeout(variablesSaveTimer);
-    variablesSaveTimer = null;
-  }
-  await saveDebugVariables(false);
-  ElMessage.success("变量已删除");
-};
-
-// 重置变量表单
-const resetVariableForm = () => {
-  variableForm.value = {
-    name: "",
-    value: "",
-    desc: "",
-  };
-  editingVariableIndex.value = -1;
-};
-
-// 打开添加变量对话框
-const openAddVariableDialog = () => {
-  resetVariableForm();
-  showAddVariableDialog.value = true;
-};
-
-// 替换变量模板为实际值
-const replaceVariables = (text) => {
-  if (!text || typeof text !== "string") return text;
-  let result = text;
-  debugVariables.value.forEach((variable) => {
-    const regex = new RegExp(`\\{\\{${variable.name}\\}\\}`, "g");
-    result = result.replace(regex, variable.value);
-  });
-  return result;
-};
-
-// 判断是否为复杂类型（需要JSON格式）
-const isComplexType = (field) => {
-  if (!field) return false;
-
-  // 基本类型（String, Integer, Long, Double, Float, Boolean, Date, DateTime等）不是复杂类型
-  if (field.basicProperty) {
-    // 但是List/Set/Array/Map等集合类型需要JSON格式
-    if (
-      field.typeName === "List" ||
-      field.typeName === "Set" ||
-      field.typeName === "Array" ||
-      field.typeName === "Map"
-    ) {
-      return true;
-    }
-    // 其他基本类型（如String, Integer等）不是复杂类型
-    return false;
-  }
-
-  // 对象类型或数组类型需要JSON格式
-  // 如果有model属性，说明是对象类型
-  // 如果有parametricModels，说明是泛型类型
-  return field.model || (field.parametricModels && field.parametricModels.length > 0);
-};
-
-// 根据字段类型生成验证规则
-const generateTypeValidationRules = (field) => {
-  const rules = [];
-  const typeName = field.typeName;
-
-  if (!field || !typeName) return rules;
-
-  // 枚举类型验证
-  if (
-    field.enumInfo &&
-    field.enumInfo.properties &&
-    field.enumInfo.properties.length > 0
-  ) {
-    const enumValues = field.enumInfo.properties.map((item) => item.value);
-    rules.push({
-      validator: (rule, value, callback) => {
-        if (!value) {
-          callback();
-          return;
-        }
-        // 检查是否包含变量模板
-        const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-        if (hasVariableTemplate) {
-          // 如果包含变量模板，先替换变量再验证
-          let actualValue = replaceVariables(value);
-          // 如果替换后仍然是模板（变量不存在），允许通过（在发送请求时再验证）
-          if (/\{\{[\w]+\}\}/.test(actualValue)) {
-            callback();
-            return;
-          }
-          // 替换后验证
-          const numValue = Number(actualValue);
-          const isNumericEnum = enumValues.some((v) => Number(v) === numValue);
-          const isStringEnum = enumValues.includes(actualValue);
-
-          if (!isNumericEnum && !isStringEnum) {
-            const enumDesc = field.enumInfo.properties
-              .map((item) => `${item.desc}(${item.value})`)
-              .join("、");
-            callback(new Error(`请输入有效的枚举值：${enumDesc}`));
-          } else {
-            callback();
-          }
-        } else {
-          // 没有变量模板，直接验证
-          const numValue = Number(value);
-          const isNumericEnum = enumValues.some((v) => Number(v) === numValue);
-          const isStringEnum = enumValues.includes(value);
-
-          if (!isNumericEnum && !isStringEnum) {
-            const enumDesc = field.enumInfo.properties
-              .map((item) => `${item.desc}(${item.value})`)
-              .join("、");
-            callback(new Error(`请输入有效的枚举值：${enumDesc}`));
-          } else {
-            callback();
-          }
-        }
-      },
-      trigger: "blur",
-    });
-    return rules; // 枚举类型优先，直接返回
-  }
-
-  // 复杂类型（对象、数组等）需要JSON格式
-  if (isComplexType(field)) {
-    rules.push({
-      validator: (rule, value, callback) => {
-        if (!value) {
-          callback();
-          return;
-        }
-        // 检查是否包含变量模板
-        const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-        if (hasVariableTemplate) {
-          // 如果包含变量模板，先替换变量再验证
-          let actualValue = replaceVariables(value);
-          // 如果替换后仍然是模板（变量不存在），允许通过
-          if (/\{\{[\w]+\}\}/.test(actualValue)) {
-            callback();
-            return;
-          }
-          // 替换后验证JSON格式
-          try {
-            const parsed = JSON.parse(actualValue);
-            // 对于List/Set/Array类型，验证是否为数组
-            if (typeName === "List" || typeName === "Set" || typeName === "Array") {
-              if (!Array.isArray(parsed)) {
-                callback(new Error("请输入有效的数组格式（JSON数组）"));
-                return;
-              }
-            }
-            // 对于Map类型，验证是否为对象
-            if (typeName === "Map") {
-              if (typeof parsed !== "object" || Array.isArray(parsed)) {
-                callback(new Error("请输入有效的对象格式（JSON对象）"));
-                return;
-              }
-            }
-            callback();
-          } catch (e) {
-            callback(new Error("请输入有效的JSON格式"));
-          }
-        } else {
-          // 没有变量模板，直接验证JSON格式
-          try {
-            const parsed = JSON.parse(value);
-            // 对于List/Set/Array类型，验证是否为数组
-            if (typeName === "List" || typeName === "Set" || typeName === "Array") {
-              if (!Array.isArray(parsed)) {
-                callback(new Error("请输入有效的数组格式（JSON数组）"));
-                return;
-              }
-            }
-            // 对于Map类型，验证是否为对象
-            if (typeName === "Map") {
-              if (typeof parsed !== "object" || Array.isArray(parsed)) {
-                callback(new Error("请输入有效的对象格式（JSON对象）"));
-                return;
-              }
-            }
-            callback();
-          } catch (e) {
-            callback(new Error("请输入有效的JSON格式"));
-          }
-        }
-      },
-      trigger: "blur",
-    });
-    return rules;
-  }
-
-  // 基本类型验证
-  switch (typeName) {
-    case "String":
-      // 字符串类型，不需要特殊验证（任何输入都是字符串）
-      break;
-
-    case "Integer":
-    case "int":
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value) {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            const numValue = Number(actualValue);
-            if (isNaN(numValue) || !Number.isInteger(numValue)) {
-              callback(new Error(`请输入有效的整数`));
-            } else {
-              callback();
-            }
-          } else {
-            // 没有变量模板，直接验证
-            const numValue = Number(value);
-            if (isNaN(numValue) || !Number.isInteger(numValue)) {
-              callback(new Error(`请输入有效的整数`));
-            } else {
-              callback();
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    case "Long":
-    case "long":
-      // long类型作为字符串处理，避免精度丢失
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value) {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            // long类型验证为字符串格式的数字
-            if (typeof actualValue !== "string") {
-              callback(new Error(`请输入字符串格式的数字（long类型）`));
-            } else {
-              // 验证是否为有效的数字字符串（支持大整数）
-              const numRegex = /^-?\d+$/;
-              if (!numRegex.test(actualValue.trim())) {
-                callback(new Error(`请输入有效的数字字符串（long类型）`));
-              } else {
-                callback();
-              }
-            }
-          } else {
-            // 没有变量模板，直接验证
-            if (typeof value !== "string") {
-              callback(new Error(`请输入字符串格式的数字（long类型）`));
-            } else {
-              // 验证是否为有效的数字字符串（支持大整数）
-              const numRegex = /^-?\d+$/;
-              if (!numRegex.test(value.trim())) {
-                callback(new Error(`请输入有效的数字字符串（long类型）`));
-              } else {
-                callback();
-              }
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    case "Double":
-    case "Float":
-    case "double":
-    case "float":
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value) {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            const numValue = Number(actualValue);
-            if (isNaN(numValue)) {
-              callback(new Error(`请输入有效的数字`));
-            } else {
-              callback();
-            }
-          } else {
-            // 没有变量模板，直接验证
-            const numValue = Number(value);
-            if (isNaN(numValue)) {
-              callback(new Error(`请输入有效的数字`));
-            } else {
-              callback();
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    case "Boolean":
-    case "boolean":
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value && value !== "0" && value !== "false") {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            const lowerValue = String(actualValue).toLowerCase();
-            if (
-              lowerValue !== "true" &&
-              lowerValue !== "false" &&
-              lowerValue !== "1" &&
-              lowerValue !== "0"
-            ) {
-              callback(new Error(`请输入有效的布尔值（true/false 或 1/0）`));
-            } else {
-              callback();
-            }
-          } else {
-            // 没有变量模板，直接验证
-            const lowerValue = String(value).toLowerCase();
-            if (
-              lowerValue !== "true" &&
-              lowerValue !== "false" &&
-              lowerValue !== "1" &&
-              lowerValue !== "0"
-            ) {
-              callback(new Error(`请输入有效的布尔值（true/false 或 1/0）`));
-            } else {
-              callback();
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    case "Date":
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value) {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            // 验证日期格式 YYYY-MM-DD
-            const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-            if (!dateRegex.test(actualValue)) {
-              callback(new Error(`请输入有效的日期格式（YYYY-MM-DD）`));
-            } else {
-              const date = new Date(actualValue);
-              if (isNaN(date.getTime())) {
-                callback(new Error(`请输入有效的日期`));
-              } else {
-                callback();
-              }
-            }
-          } else {
-            // 没有变量模板，直接验证
-            const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-            if (!dateRegex.test(value)) {
-              callback(new Error(`请输入有效的日期格式（YYYY-MM-DD）`));
-            } else {
-              const date = new Date(value);
-              if (isNaN(date.getTime())) {
-                callback(new Error(`请输入有效的日期`));
-              } else {
-                callback();
-              }
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    case "DateTime":
-      rules.push({
-        validator: (rule, value, callback) => {
-          if (!value) {
-            callback();
-            return;
-          }
-          // 检查是否包含变量模板
-          const hasVariableTemplate = /\{\{[\w]+\}\}/.test(value);
-          if (hasVariableTemplate) {
-            // 如果包含变量模板，先替换变量再验证
-            let actualValue = replaceVariables(value);
-            // 如果替换后仍然是模板（变量不存在），允许通过
-            if (/\{\{[\w]+\}\}/.test(actualValue)) {
-              callback();
-              return;
-            }
-            // 验证日期时间格式 YYYY-MM-DD HH:mm:ss 或 YYYY-MM-DDTHH:mm:ss
-            const dateTimeRegex = /^\d{4}-\d{2}-\d{2}(\s|T)\d{2}:\d{2}:\d{2}$/;
-            if (!dateTimeRegex.test(actualValue)) {
-              callback(new Error(`请输入有效的日期时间格式（YYYY-MM-DD HH:mm:ss）`));
-            } else {
-              const date = new Date(actualValue.replace(" ", "T"));
-              if (isNaN(date.getTime())) {
-                callback(new Error(`请输入有效的日期时间`));
-              } else {
-                callback();
-              }
-            }
-          } else {
-            // 没有变量模板，直接验证
-            const dateTimeRegex = /^\d{4}-\d{2}-\d{2}(\s|T)\d{2}:\d{2}:\d{2}$/;
-            if (!dateTimeRegex.test(value)) {
-              callback(new Error(`请输入有效的日期时间格式（YYYY-MM-DD HH:mm:ss）`));
-            } else {
-              const date = new Date(value.replace(" ", "T"));
-              if (isNaN(date.getTime())) {
-                callback(new Error(`请输入有效的日期时间`));
-              } else {
-                callback();
-              }
-            }
-          }
-        },
-        trigger: "blur",
-      });
-      break;
-
-    default:
-      // 其他类型，不添加特殊验证
-      break;
-  }
-
-  return rules;
-};
-
-// 接口选择处理
-// 获取当前选中接口的action
-const getCurrentApiAction = () => {
-  if (!debugForm.value.selectedApi) {
-    return "";
-  }
-  const api = apis.value.find((a) => a.uniqueId === debugForm.value.selectedApi);
-  return api ? api.action : "";
-};
-
-const onApiSelected = async (apiUniqueId) => {
-  if (!apiUniqueId) {
-    debugFormParams.value = [];
-    selectedApiDetail.value = null;
-    return;
-  }
-
-  // 保存当前接口的缓存（如果有选中的接口）
-  if (debugForm.value.selectedApi && debugForm.value.selectedApi !== apiUniqueId) {
-    const currentCacheData = {
-      token: debugForm.value.token,
-      params: debugForm.value.params,
-      jsonParams: debugForm.value.jsonParams,
-      paramInputMode: paramInputMode.value,
-      debugResult: debugResult.value,
-      debugResultTab: debugResultTab.value,
-      debugLogs: debugLogs.value,
-      timestamp: Date.now(),
-    };
-    await saveApiDebugCache(debugForm.value.selectedApi, currentCacheData);
-  }
-
-  const api = apis.value.find((a) => a.uniqueId === apiUniqueId);
-  if (!api) return;
-
-  // 先尝试加载缓存数据
-  const cachedData = await loadApiDebugCache(apiUniqueId);
-
-  // 清空之前的参数
-  debugForm.value.params = {};
-  debugForm.value.jsonParams = "";
-
-  // 加载接口详情
-  try {
-    const response = await axios.get(hostUrl.value, {
-      params: {
-        action: "getActionDetail",
-        id: api.originalId || api.id,
-      },
-    });
-    selectedApiDetail.value = response.data.data;
-
-    // 生成参数表单
-    generateDebugFormParams(selectedApiDetail.value.paramModel);
-
-    // 如果有缓存数据，使用缓存数据填充表单
-    if (cachedData) {
-      // 填充token
-      if (cachedData.token) {
-        debugForm.value.token = cachedData.token;
-      }
-
-      // 填充参数（根据当前模式）
-      if (cachedData.paramInputMode === "json" && cachedData.jsonParams) {
-        // JSON模式
-        debugForm.value.jsonParams = cachedData.jsonParams;
-        paramInputMode.value = "json";
-      } else if (cachedData.params) {
-        // 表单模式
-        debugForm.value.params = { ...cachedData.params };
-        paramInputMode.value = "form";
-      }
-
-      // 如果有调试结果，也加载
-      if (cachedData.debugResult) {
-        debugResult.value = cachedData.debugResult;
-        debugResultTab.value = cachedData.debugResultTab || "response";
-      }
-
-      // 如果有日志，也加载
-      if (cachedData.debugLogs && cachedData.debugLogs.length > 0) {
-        debugLogs.value = cachedData.debugLogs;
-      }
-
-      ElMessage.success("已加载缓存数据");
-    } else {
-      // 没有缓存，生成示例JSON参数
-      debugForm.value.jsonParams = generateExampleJsonParams();
-    }
-  } catch (error) {
-    console.error("Failed to fetch API detail:", error);
-    ElMessage.warning("获取接口详情失败");
-    selectedApiDetail.value = null;
-    debugFormParams.value = [];
-    debugForm.value.jsonParams = "";
-  }
-};
-
-// 生成调试表单参数
-const generateDebugFormParams = (paramModel) => {
-  debugFormParams.value = [];
-  if (!paramModel) return;
-
-  // 获取所有模型，但只处理根模型的字段（避免嵌套字段重复）
-  const models = getAllModels(paramModel);
-  const processedFields = new Set(); // 用于跟踪已处理的字段
-
-  // 优先处理根模型
-  if (paramModel.fields && paramModel.fields.length > 0) {
-    paramModel.fields.forEach((field) => {
-      if (processedFields.has(field.name)) return;
-      processedFields.add(field.name);
-
-      const rules = [];
-      if (field.required) {
-        rules.push({
-          required: true,
-          message: `请输入${field.name}`,
-          trigger: "blur",
-        });
-      }
-
-      // 根据字段类型添加验证规则
-      const typeRules = generateTypeValidationRules(field);
-      rules.push(...typeRules);
-
-      debugFormParams.value.push({
-        name: field.name,
-        type: field.typeName,
-        required: field.required,
-        desc: field.desc,
-        enumInfo: field.enumInfo,
-        rules: rules,
-        field: field, // 保存原始字段信息
-      });
-
-      // 初始化参数值
-      if (!debugForm.value.params[field.name]) {
-        debugForm.value.params[field.name] = "";
-      }
-    });
-  }
-
-  // 如果没有根模型字段，尝试从其他模型中获取
-  if (debugFormParams.value.length === 0 && models.length > 0) {
-    models.forEach((model) => {
-      if (model.fields && model.fields.length > 0) {
-        model.fields.forEach((field) => {
-          if (processedFields.has(field.name)) return;
-          processedFields.add(field.name);
-
-          const rules = [];
-          if (field.required) {
-            rules.push({
-              required: true,
-              message: `请输入${field.name}`,
-              trigger: "blur",
-            });
-          }
-
-          // 根据字段类型添加验证规则
-          const typeRules = generateTypeValidationRules(field);
-          rules.push(...typeRules);
-
-          debugFormParams.value.push({
-            name: field.name,
-            type: field.typeName,
-            required: field.required,
-            desc: field.desc,
-            enumInfo: field.enumInfo,
-            rules: rules,
-            field: field,
-          });
-
-          if (!debugForm.value.params[field.name]) {
-            debugForm.value.params[field.name] = "";
-          }
-        });
-      }
-    });
-  }
-};
-
-// 根据字段类型生成示例值
-const generateExampleValue = (field) => {
-  if (!field) return null;
-
-  // 枚举类型，返回第一个枚举值
-  if (
-    field.enumInfo &&
-    field.enumInfo.properties &&
-    field.enumInfo.properties.length > 0
-  ) {
-    return field.enumInfo.properties[0].value;
-  }
-
-  const typeName = field.typeName;
-
-  // 复杂类型
-  if (isComplexType(field)) {
-    if (typeName === "List" || typeName === "Set" || typeName === "Array") {
-      return [];
-    }
-    if (typeName === "Map") {
-      return {};
-    }
-    // 对象类型，返回空对象
-    if (field.model) {
-      return {};
-    }
-    return {};
-  }
-
-  // 基本类型
-  switch (typeName) {
-    case "String":
-      return "";
-    case "Integer":
-    case "int":
-      return 0;
-    case "Long":
-    case "long":
-      // long类型作为字符串处理，避免精度丢失
-      return "0";
-    case "Double":
-    case "Float":
-    case "double":
-    case "float":
-      return 0.0;
-    case "Boolean":
-    case "boolean":
-      return false;
-    case "Date":
-      return "2024-01-01";
-    case "DateTime":
-      return "2024-01-01 00:00:00";
-    default:
-      return "";
-  }
-};
-
-// 生成示例JSON参数
-const generateExampleJsonParams = (currentParams = {}) => {
-  if (!selectedApiDetail.value || !selectedApiDetail.value.paramModel) {
-    return "{}";
-  }
-
-  const paramModel = selectedApiDetail.value.paramModel;
-  const exampleParams = {};
-
-  // 获取所有字段
-  const models = getAllModels(paramModel);
-  const processedFields = new Set();
-
-  // 优先处理根模型的字段
-  if (paramModel.fields && paramModel.fields.length > 0) {
-    paramModel.fields.forEach((field) => {
-      if (processedFields.has(field.name)) return;
-      processedFields.add(field.name);
-      exampleParams[field.name] = generateExampleValue(field);
-    });
-  }
-
-  // 如果没有根模型字段，从其他模型中获取
-  if (Object.keys(exampleParams).length === 0 && models.length > 0) {
-    models.forEach((model) => {
-      if (model.fields && model.fields.length > 0) {
-        model.fields.forEach((field) => {
-          if (processedFields.has(field.name)) return;
-          processedFields.add(field.name);
-          exampleParams[field.name] = generateExampleValue(field);
-        });
-      }
-    });
-  }
-
-  return JSON.stringify(Object.assign(exampleParams, currentParams), null, 2);
-};
-
-// 参数模式切换处理
-const onParamModeChange = (mode) => {
-  if (mode === "json") {
-    // 切换到JSON模式时，将表单数据转换为JSON
-    if (Object.keys(debugForm.value.params).length > 0) {
-      // 如果有表单数据，转换为JSON
-      try {
-        // 处理表单数据，根据字段类型转换值
-        const jsonParams = {};
-        Object.keys(debugForm.value.params).forEach((key) => {
-          let value = debugForm.value.params[key];
-          if (value || value === 0 || value === false) {
-            // 找到对应的字段信息
-            const paramField = debugFormParams.value.find((p) => p.name === key);
-            if (paramField && paramField.field) {
-              // 根据字段类型转换值
-              jsonParams[key] = convertParamValue(value, paramField.field);
-            } else {
-              jsonParams[key] = value;
-            }
-          }
-        });
-        debugForm.value.jsonParams = generateExampleJsonParams(jsonParams); //JSON.stringify(jsonParams, null, 2);
-      } catch (e) {
-        console.error("Failed to convert form data to JSON:", e);
-        // 如果转换失败，生成示例JSON
-        debugForm.value.jsonParams = generateExampleJsonParams();
-      }
-    } else if (!debugForm.value.jsonParams || debugForm.value.jsonParams.trim() === "") {
-      // 如果表单数据为空且JSON也为空，生成示例JSON
-      debugForm.value.jsonParams = generateExampleJsonParams();
-    }
-  } else {
-    // 切换到表单模式时，将JSON数据转换为表单数据
-    jsonParamsError.value = "";
-
-    if (debugForm.value.jsonParams && debugForm.value.jsonParams.trim() !== "") {
-      try {
-        const jsonData = JSON.parse(debugForm.value.jsonParams);
-        // 将JSON数据填入表单
-        Object.keys(jsonData).forEach((key) => {
-          const value = jsonData[key];
-          // 根据字段类型决定如何显示
-          const paramField = debugFormParams.value.find((p) => p.name === key);
-          if (paramField && isComplexType(paramField.field)) {
-            // 复杂类型，转换为JSON字符串
-            debugForm.value.params[key] = JSON.stringify(value, null, 2);
-          } else {
-            // 基本类型，直接转换为字符串
-            debugForm.value.params[key] = String(value);
-          }
-        });
-      } catch (e) {
-        console.error("Failed to convert JSON to form data:", e);
-        // 如果JSON解析失败，清空表单数据
-        debugForm.value.params = {};
-      }
-    } else {
-      // 如果JSON为空，清空表单数据
-      debugForm.value.params = {};
-    }
-  }
-};
-
-// 格式化JSON参数
-const formatJsonParams = () => {
-  if (!debugForm.value.jsonParams || debugForm.value.jsonParams.trim() === "") {
-    return;
-  }
-
-  try {
-    const parsed = JSON.parse(debugForm.value.jsonParams);
-    debugForm.value.jsonParams = JSON.stringify(parsed, null, 2);
-    jsonParamsError.value = "";
-    ElMessage.success("格式化成功");
-  } catch (e) {
-    jsonParamsError.value = "JSON格式错误: " + e.message;
-    ElMessage.error("JSON格式错误");
-  }
-};
-
-// 重置JSON参数为示例
-const resetJsonParams = () => {
-  debugForm.value.jsonParams = generateExampleJsonParams();
-  jsonParamsError.value = "";
-  ElMessage.success("已重置为示例JSON");
-};
-
-// 验证JSON参数
-const validateJsonParams = () => {
-  if (!debugForm.value.jsonParams || debugForm.value.jsonParams.trim() === "") {
-    jsonParamsError.value = "";
-    return true;
-  }
-
-  try {
-    JSON.parse(debugForm.value.jsonParams);
-    jsonParamsError.value = "";
-    return true;
-  } catch (e) {
-    jsonParamsError.value = "JSON格式错误: " + e.message;
-    return false;
-  }
-};
-
-// 重置调试表单（只重置参数，保留选中的接口）
-const resetDebugForm = () => {
-  // 保留选中的接口和接口详情
-  const selectedApi = debugForm.value.selectedApi;
-  const apiDetail = selectedApiDetail.value;
-
-  // 重置参数相关数据
-  debugForm.value.params = {};
-  debugForm.value.jsonParams = generateExampleJsonParams();
-  debugResult.value = null;
-  debugLogs.value = [];
-  jsonParamsError.value = "";
-  paramInputMode.value = "form";
-
-  // 恢复选中的接口（防止resetFields清除）
-  debugForm.value.selectedApi = selectedApi;
-  selectedApiDetail.value = apiDetail;
-
-  ElMessage.success("已重置");
-};
-
-// 添加调试日志
-const addDebugLog = (type, message) => {
-  debugLogs.value.push({
-    time: new Date().toLocaleTimeString(),
-    type: type,
-    message: message,
-  });
-};
-
-// 格式化调试结果
-const formatDebugResult = (result) => {
-  if (typeof result === "object") {
-    return JSON.stringify(result, null, 2);
-  }
-  return result;
-};
-
-// 获取状态码样式类
-const getStatusClass = (status) => {
-  if (!status) return "";
-  if (status >= 200 && status < 300) return "status-success";
-  if (status >= 300 && status < 400) return "status-warning";
-  if (status >= 400) return "status-error";
-  return "";
-};
-
-// 根据字段类型转换参数值
-const convertParamValue = (value, field) => {
-  if (!value && value !== 0 && value !== false) {
-    return value; // 空值直接返回
-  }
-
-  if (!field || !field.typeName) {
-    return value; // 没有类型信息，直接返回
-  }
-
-  const typeName = field.typeName;
-
-  // 复杂类型（对象、数组等）需要解析JSON
-  if (isComplexType(field)) {
-    try {
-      return JSON.parse(value);
-    } catch (e) {
-      return value;
-    }
-  }
-
-  // 基本类型转换
-  switch (typeName) {
-    case "String":
-      return String(value);
-
-    case "Integer":
-    case "int":
-      const intValue = Number(value);
-      return isNaN(intValue) ? value : Math.floor(intValue);
-
-    case "Long":
-    case "long":
-      // long类型保持为字符串，避免精度丢失
-      return String(value);
-
-    case "Double":
-    case "Float":
-    case "double":
-    case "float":
-      const floatValue = Number(value);
-      return isNaN(floatValue) ? value : floatValue;
-
-    case "Boolean":
-    case "boolean":
-      const lowerValue = String(value).toLowerCase();
-      if (lowerValue === "true" || lowerValue === "1") {
-        return true;
-      } else if (lowerValue === "false" || lowerValue === "0") {
-        return false;
-      }
-      return value;
-
-    case "Date":
-    case "DateTime":
-      // 日期类型保持字符串格式
-      return String(value);
-
-    default:
-      return value;
-  }
-};
-
-// 处理调试请求
-const handleDebug = async () => {
-  if (!debugFormRef.value) return;
-
-  // JSON模式验证
-  if (paramInputMode.value === "json") {
-    if (!validateJsonParams()) {
-      ElMessage.warning("请检查JSON格式");
-      return;
-    }
-  } else {
-    // 表单模式验证
-    try {
-      await debugFormRef.value.validate();
-    } catch (error) {
-      ElMessage.warning("请填写必填参数");
-      return;
-    }
-  }
-
-  if (!debugConfig.value.apiUrl) {
-    ElMessage.warning("请先配置接口URL");
-    return;
-  }
-
-  if (!debugForm.value.selectedApi) {
-    ElMessage.warning("请选择要调试的接口");
-    return;
-  }
-
-  const api = apis.value.find((a) => a.uniqueId === debugForm.value.selectedApi);
-  if (!api) {
-    ElMessage.warning("接口不存在");
-    return;
-  }
-
-  debugging.value = true;
-  debugResult.value = null;
-  debugLogs.value = [];
-
-  try {
-    // 替换变量
-    let token = replaceVariables(debugForm.value.token);
-    let params = {};
-
-    // 根据模式处理参数
-    if (paramInputMode.value === "json") {
-      // JSON模式：解析JSON并替换变量
-      if (debugForm.value.jsonParams && debugForm.value.jsonParams.trim()) {
-        try {
-          // 先替换JSON字符串中的变量
-          let jsonStr = replaceVariables(debugForm.value.jsonParams);
-          params = JSON.parse(jsonStr);
-        } catch (e) {
-          ElMessage.error("JSON解析失败: " + e.message);
-          debugging.value = false;
-          return;
-        }
-      }
-    } else {
-      // 表单模式：处理表单参数
-      Object.keys(debugForm.value.params).forEach((key) => {
-        let value = debugForm.value.params[key];
-        if (value || value === 0 || value === false) {
-          // 先替换变量
-          value = replaceVariables(value);
-          // 找到对应的字段信息
-          const paramField = debugFormParams.value.find((p) => p.name === key);
-          if (paramField && paramField.field) {
-            // 根据字段类型转换值
-            params[key] = convertParamValue(value, paramField.field);
-          } else {
-            params[key] = value;
-          }
-        }
-      });
-    }
-
-    // 构建请求数据
-    const requestData = {
-      action: api.action,
-      token: token,
-      params: params,
-    };
-
-    addDebugLog("INFO", `开始请求接口: ${api.action}`);
-    addDebugLog("INFO", `请求URL: ${debugConfig.value.apiUrl}`);
-    addDebugLog("INFO", `请求数据: ${JSON.stringify(requestData, null, 2)}`);
-
-    // 发起请求
-    const startTime = Date.now();
-    const response = await axios.post(debugConfig.value.apiUrl, requestData, {
-      headers: {
-        "Content-Type": "application/json",
-      },
-    });
-    const endTime = Date.now();
-
-    addDebugLog("SUCCESS", `请求成功，耗时: ${endTime - startTime}ms`);
-    addDebugLog("INFO", `响应数据: ${JSON.stringify(response.data, null, 2)}`);
-
-    debugResult.value = {
-      response: response.data,
-      status: response.status,
-      headers: response.headers,
-      time: endTime - startTime,
-    };
-
-    ElMessage.success("调试成功");
-  } catch (error) {
-    const errorMessage = error.response?.data?.msg || error.message || "请求失败";
-    addDebugLog("ERROR", `请求失败: ${errorMessage}`);
-    if (error.response) {
-      addDebugLog("ERROR", `响应状态: ${error.response.status}`);
-      addDebugLog("ERROR", `响应数据: ${JSON.stringify(error.response.data, null, 2)}`);
-    }
-
-    debugResult.value = {
-      error: errorMessage,
-      response: error.response?.data || null,
-      status: error.response?.status || null,
-    };
-
-    ElMessage.error("调试失败: " + errorMessage);
-  } finally {
-    debugging.value = false;
-
-    // 保存调试缓存数据
-    if (debugForm.value.selectedApi) {
-      const cacheData = {
-        token: debugForm.value.token,
-        params: debugForm.value.params,
-        jsonParams: debugForm.value.jsonParams,
-        paramInputMode: paramInputMode.value,
-        debugResult: debugResult.value,
-        debugResultTab: debugResultTab.value,
-        debugLogs: debugLogs.value,
-        timestamp: Date.now(), // 保存时间戳
-      };
-      await saveApiDebugCache(debugForm.value.selectedApi, cacheData);
-    }
-  }
-};
 
 onMounted(async () => {
   checkDeviceType();
@@ -2838,9 +1114,6 @@ onMounted(async () => {
     loading.value = false;
   }
 
-  // 加载调试配置和变量
-  await loadDebugConfig();
-  await loadDebugVariables();
 });
 
 // 根据id查找API
@@ -2871,13 +1144,6 @@ const goHome = () => {
 const goToApi = (api) => {
   showApiDetail(api);
   updateUrlParameter(api.uniqueId);
-
-  // 如果当前在调试标签页，自动选择对应的接口
-  if (activeTab.value === "debug") {
-    debugForm.value.selectedApi = api.uniqueId;
-    // 触发接口选择处理，加载接口详情和缓存
-    onApiSelected(api.uniqueId);
-  }
 };
 
 const checkDeviceType = () => {
@@ -3005,20 +1271,32 @@ const getExampleValue = (field) => {
   return null;
 };
 
+const isModelGroup = (model) => {
+  return (
+    model &&
+    !model.basicProperty &&
+    Array.isArray(model.fields) &&
+    model.fields.length > 0
+  );
+};
+
 const getAllModels = (model, parentInfo) => {
-  if (!model) return [];
+  if (!isModelGroup(model)) return [];
+
   let models = [Object.assign({ parentInfo }, model)];
 
   // 处理泛型模型
   if (model.parametricModels) {
     model.parametricModels.forEach((parametricModel, index) => {
-      models.push(
-        ...getAllModels(parametricModel, {
-          index,
-          length: model.parametricModels.length,
-          simpleName: model.simpleName,
-        })
-      );
+      if (isModelGroup(parametricModel)) {
+        models.push(
+          ...getAllModels(parametricModel, {
+            index,
+            length: model.parametricModels.length,
+            simpleName: model.simpleName,
+          })
+        );
+      }
     });
   }
 
@@ -3026,19 +1304,25 @@ const getAllModels = (model, parentInfo) => {
   (model.fields || []).forEach((field) => {
     if (field.parametricModels) {
       field.parametricModels.forEach((parametricModel) => {
-        models.push(...getAllModels(parametricModel));
+        if (isModelGroup(parametricModel)) {
+          models.push(...getAllModels(parametricModel));
+        }
       });
     }
-    if (field.model) {
+    if (field.model && !field.basicProperty) {
       models.push(...getAllModels(field.model));
     }
   });
 
-  return models.filter((m) => m && m.fields);
+  return models;
 };
 
+// 是否应显示模型锚点链接（basicProperty 及无字段的基础类型不跳转）
 const isObjectType = (field) => {
-  return field && !field.basicProperty;
+  if (!field || field.basicProperty) return false;
+  if (field.model?.basicProperty) return false;
+  if (field.model) return isModelGroup(field.model);
+  return !field.basicProperty;
 };
 
 const isGenericType = (field) => {
@@ -3060,7 +1344,7 @@ const getGenericParams = (field) => {
     .filter((item) => !!item)
     .map((item) => ({
       name: item.simpleName || "",
-      isObject: !item.basicProperty,
+      isObject: isModelGroup(item),
     }));
 };
 
@@ -3547,75 +1831,83 @@ const generateMarkdownDocumentation = (allApiDetails) => {
       // 请求参数
       if (detail.paramModel) {
         markdown += "#### 请求参数\n\n";
-        const models = getAllModels(detail.paramModel);
-        if (models.length > 0) {
-          models.forEach((model) => {
-            markdown += `**${model.simpleName}**\n\n`;
-            markdown += "| 参数名 | 类型 | 必填 | 说明 |\n";
-            markdown += "|--------|------|------|----------|\n";
-            (model.fields || []).forEach((field) => {
-              const typeName = getFullTypeName(field);
-              const required = field.required ? "是" : "否";
-              let desc = field.desc || "-";
-
-              // 如果是枚举类型，添加枚举值信息
-              if (
-                field.enumInfo &&
-                field.enumInfo.properties &&
-                field.enumInfo.properties.length > 0
-              ) {
-                const enumValues = field.enumInfo.properties
-                  .map((item) => `${item.desc}(${item.value})`)
-                  .join("、");
-                desc =
-                  desc !== "-"
-                    ? `${desc}；枚举值：${enumValues}`
-                    : `枚举值：${enumValues}`;
-              }
-
-              markdown += `| ${field.name} | ${typeName} | ${required} | ${desc} |\n`;
-            });
-            markdown += "\n";
-          });
+        if (detail.paramModel.basicProperty) {
+          markdown += `类型：${getFullTypeName(detail.paramModel)}\n\n`;
         } else {
-          markdown += "无参数\n\n";
+          const models = getAllModels(detail.paramModel);
+          if (models.length > 0) {
+            models.forEach((model) => {
+              markdown += `**${model.simpleName}**\n\n`;
+              markdown += "| 参数名 | 类型 | 必填 | 说明 |\n";
+              markdown += "|--------|------|------|----------|\n";
+              (model.fields || []).forEach((field) => {
+                const typeName = getFullTypeName(field);
+                const required = field.required ? "是" : "否";
+                let desc = field.desc || "-";
+
+                // 如果是枚举类型，添加枚举值信息
+                if (
+                  field.enumInfo &&
+                  field.enumInfo.properties &&
+                  field.enumInfo.properties.length > 0
+                ) {
+                  const enumValues = field.enumInfo.properties
+                    .map((item) => `${item.desc}(${item.value})`)
+                    .join("、");
+                  desc =
+                    desc !== "-"
+                      ? `${desc}；枚举值：${enumValues}`
+                      : `枚举值：${enumValues}`;
+                }
+
+                markdown += `| ${field.name} | ${typeName} | ${required} | ${desc} |\n`;
+              });
+              markdown += "\n";
+            });
+          } else {
+            markdown += "无参数\n\n";
+          }
         }
       }
 
       // 请求响应
       if (detail.responseModel) {
         markdown += "#### 请求响应\n\n";
-        const models = getAllModels(detail.responseModel);
-        if (models.length > 0) {
-          models.forEach((model) => {
-            markdown += `**${model.simpleName}**\n\n`;
-            markdown += "| 字段名 | 类型 | 说明 |\n";
-            markdown += "|--------|------|------|\n";
-            (model.fields || []).forEach((field) => {
-              const typeName = getFullTypeName(field);
-              let desc = field.desc || "-";
-
-              // 如果是枚举类型，添加枚举值信息
-              if (
-                field.enumInfo &&
-                field.enumInfo.properties &&
-                field.enumInfo.properties.length > 0
-              ) {
-                const enumValues = field.enumInfo.properties
-                  .map((item) => `${item.desc}(${item.value})`)
-                  .join("、");
-                desc =
-                  desc !== "-"
-                    ? `${desc}；枚举值：${enumValues}`
-                    : `枚举值：${enumValues}`;
-              }
-
-              markdown += `| ${field.name} | ${typeName} | ${desc} |\n`;
-            });
-            markdown += "\n";
-          });
+        if (detail.responseModel.basicProperty) {
+          markdown += `类型：${getFullTypeName(detail.responseModel)}\n\n`;
         } else {
-          markdown += "无响应数据\n\n";
+          const models = getAllModels(detail.responseModel);
+          if (models.length > 0) {
+            models.forEach((model) => {
+              markdown += `**${model.simpleName}**\n\n`;
+              markdown += "| 字段名 | 类型 | 说明 |\n";
+              markdown += "|--------|------|------|\n";
+              (model.fields || []).forEach((field) => {
+                const typeName = getFullTypeName(field);
+                let desc = field.desc || "-";
+
+                // 如果是枚举类型，添加枚举值信息
+                if (
+                  field.enumInfo &&
+                  field.enumInfo.properties &&
+                  field.enumInfo.properties.length > 0
+                ) {
+                  const enumValues = field.enumInfo.properties
+                    .map((item) => `${item.desc}(${item.value})`)
+                    .join("、");
+                  desc =
+                    desc !== "-"
+                      ? `${desc}；枚举值：${enumValues}`
+                      : `枚举值：${enumValues}`;
+                }
+
+                markdown += `| ${field.name} | ${typeName} | ${desc} |\n`;
+              });
+              markdown += "\n";
+            });
+          } else {
+            markdown += "无响应数据\n\n";
+          }
         }
       } else {
         markdown += "#### 请求响应\n\n";
@@ -3662,71 +1954,79 @@ const generateSingleApiMarkdown = (api, detail) => {
     // 请求参数
     if (detail.paramModel) {
       markdown += "### 请求参数\n\n";
-      const models = getAllModels(detail.paramModel);
-      if (models.length > 0) {
-        models.forEach((model) => {
-          markdown += `**${model.simpleName}**\n\n`;
-          markdown += "| 参数名 | 类型 | 必填 | 说明 |\n";
-          markdown += "|--------|------|------|----------|\n";
-          (model.fields || []).forEach((field) => {
-            const typeName = getFullTypeName(field);
-            const required = field.required ? "是" : "否";
-            let desc = field.desc || "-";
-
-            // 如果是枚举类型，添加枚举值信息
-            if (
-              field.enumInfo &&
-              field.enumInfo.properties &&
-              field.enumInfo.properties.length > 0
-            ) {
-              const enumValues = field.enumInfo.properties
-                .map((item) => `${item.desc}(${item.value})`)
-                .join("、");
-              desc =
-                desc !== "-" ? `${desc}；枚举值：${enumValues}` : `枚举值：${enumValues}`;
-            }
-
-            markdown += `| ${field.name} | ${typeName} | ${required} | ${desc} |\n`;
-          });
-          markdown += "\n";
-        });
+      if (detail.paramModel.basicProperty) {
+        markdown += `类型：${getFullTypeName(detail.paramModel)}\n\n`;
       } else {
-        markdown += "无参数\n\n";
+        const models = getAllModels(detail.paramModel);
+        if (models.length > 0) {
+          models.forEach((model) => {
+            markdown += `**${model.simpleName}**\n\n`;
+            markdown += "| 参数名 | 类型 | 必填 | 说明 |\n";
+            markdown += "|--------|------|------|----------|\n";
+            (model.fields || []).forEach((field) => {
+              const typeName = getFullTypeName(field);
+              const required = field.required ? "是" : "否";
+              let desc = field.desc || "-";
+
+              // 如果是枚举类型，添加枚举值信息
+              if (
+                field.enumInfo &&
+                field.enumInfo.properties &&
+                field.enumInfo.properties.length > 0
+              ) {
+                const enumValues = field.enumInfo.properties
+                  .map((item) => `${item.desc}(${item.value})`)
+                  .join("、");
+                desc =
+                  desc !== "-" ? `${desc}；枚举值：${enumValues}` : `枚举值：${enumValues}`;
+              }
+
+              markdown += `| ${field.name} | ${typeName} | ${required} | ${desc} |\n`;
+            });
+            markdown += "\n";
+          });
+        } else {
+          markdown += "无参数\n\n";
+        }
       }
     }
 
     // 请求响应
     if (detail.responseModel) {
       markdown += "### 请求响应\n\n";
-      const models = getAllModels(detail.responseModel);
-      if (models.length > 0) {
-        models.forEach((model) => {
-          markdown += `**${model.simpleName}**\n\n`;
-          markdown += "| 字段名 | 类型 | 说明 |\n";
-          markdown += "|--------|------|------|\n";
-          (model.fields || []).forEach((field) => {
-            const typeName = getFullTypeName(field);
-            let desc = field.desc || "-";
-
-            // 如果是枚举类型，添加枚举值信息
-            if (
-              field.enumInfo &&
-              field.enumInfo.properties &&
-              field.enumInfo.properties.length > 0
-            ) {
-              const enumValues = field.enumInfo.properties
-                .map((item) => `${item.desc}(${item.value})`)
-                .join("、");
-              desc =
-                desc !== "-" ? `${desc}；枚举值：${enumValues}` : `枚举值：${enumValues}`;
-            }
-
-            markdown += `| ${field.name} | ${typeName} | ${desc} |\n`;
-          });
-          markdown += "\n";
-        });
+      if (detail.responseModel.basicProperty) {
+        markdown += `类型：${getFullTypeName(detail.responseModel)}\n\n`;
       } else {
-        markdown += "无响应数据\n\n";
+        const models = getAllModels(detail.responseModel);
+        if (models.length > 0) {
+          models.forEach((model) => {
+            markdown += `**${model.simpleName}**\n\n`;
+            markdown += "| 字段名 | 类型 | 说明 |\n";
+            markdown += "|--------|------|------|\n";
+            (model.fields || []).forEach((field) => {
+              const typeName = getFullTypeName(field);
+              let desc = field.desc || "-";
+
+              // 如果是枚举类型，添加枚举值信息
+              if (
+                field.enumInfo &&
+                field.enumInfo.properties &&
+                field.enumInfo.properties.length > 0
+              ) {
+                const enumValues = field.enumInfo.properties
+                  .map((item) => `${item.desc}(${item.value})`)
+                  .join("、");
+                desc =
+                  desc !== "-" ? `${desc}；枚举值：${enumValues}` : `枚举值：${enumValues}`;
+              }
+
+              markdown += `| ${field.name} | ${typeName} | ${desc} |\n`;
+            });
+            markdown += "\n";
+          });
+        } else {
+          markdown += "无响应数据\n\n";
+        }
       }
     } else {
       markdown += "### 请求响应\n\n";
@@ -3812,65 +2112,6 @@ watch(exportSearchQuery, (val) => {
   }
 });
 
-// 监听URL配置变化，自动保存（使用防抖）
-let urlSaveTimer = null;
-watch(
-  () => debugConfig.value.apiUrl,
-  () => {
-    if (urlSaveTimer) {
-      clearTimeout(urlSaveTimer);
-    }
-    urlSaveTimer = setTimeout(() => {
-      saveDebugConfig(false); // 静默保存
-    }, 500); // 500ms防抖
-  }
-);
-
-// 监听token变化，自动保存（使用防抖）
-let tokenSaveTimer = null;
-watch(
-  () => debugForm.value.token,
-  () => {
-    if (tokenSaveTimer) {
-      clearTimeout(tokenSaveTimer);
-    }
-    tokenSaveTimer = setTimeout(() => {
-      saveDebugConfig(false); // 静默保存（token和URL一起保存）
-    }, 500); // 500ms防抖
-  }
-);
-
-// 监听变量变化，自动保存（使用防抖）
-let variablesSaveTimer = null;
-watch(
-  debugVariables,
-  () => {
-    if (variablesSaveTimer) {
-      clearTimeout(variablesSaveTimer);
-    }
-    variablesSaveTimer = setTimeout(() => {
-      saveDebugVariables(false); // 静默保存
-    }, 500); // 500ms防抖
-  },
-  { deep: true }
-);
-
-// 监听标签页切换，切换到调试标签页时加载配置
-watch(activeTab, async (newTab) => {
-  if (newTab === "debug") {
-    // 切换到调试标签页时，确保加载最新配置
-    await loadDebugConfig();
-    await loadDebugVariables();
-
-    // 如果当前有选中的接口，自动选择该接口
-    if (currentApi.value && currentApi.value.uniqueId) {
-      debugForm.value.selectedApi = currentApi.value.uniqueId;
-      // 触发接口选择处理，加载接口详情和缓存
-      onApiSelected(currentApi.value.uniqueId);
-    }
-  }
-});
-
 // 处理树节点选择
 const handleExportTreeCheck = (data, checked) => {
   const checkedKeys = exportTreeRef.value.getCheckedKeys();
@@ -4024,27 +2265,32 @@ const handleExportSelected = async () => {
 }
 
 .mobile-header {
-  display: flex;
+  display: grid;
+  grid-template-columns: 40px 1fr 40px;
   align-items: center;
-  background-color: #f5f7fa;
-  border-bottom: 1px solid #e6e6e6;
-  height: 60px;
+  background-color: #fff;
+  border-bottom: 1px solid #eef0f3;
+  height: 52px;
   width: 100%;
+  padding: 0 8px;
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.04);
 }
 
 .mobile-header h2 {
-  margin: 0 auto;
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: #1f2329;
+  text-align: center;
 }
 
-.menu-toggle {
-  display: flex;
-  align-items: center;
-  cursor: pointer;
-  color: var(--el-color-primary);
+.menu-toggle-btn {
+  font-size: 20px;
+  color: #303133;
 }
 
-.menu-toggle i {
-  margin-right: 5px;
+.mobile-header-spacer {
+  width: 40px;
 }
 
 .mobile-menu-close {
@@ -4054,45 +2300,113 @@ const handleExportSelected = async () => {
   color: var(--el-color-primary);
 }
 
-/* 手机端侧边栏顶部头部 */
-.mobile-sidebar-header {
+/* 手机端侧边栏顶部头部（已合并至 sidebar-header） */
+
+.el-aside.sidebar {
+  background: #f7f8fa;
+  border-right: 1px solid #e4e7ed;
+  z-index: 1000;
+  overflow: hidden;
+}
+
+.sidebar-inner {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+.sidebar-header {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  padding: 12px 16px;
-  background: #ffffff;
-  border-bottom: 1px solid #e4e7ed;
-  position: relative;
-  z-index: 10;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.04);
+  padding: 16px 16px 12px;
   flex-shrink: 0;
+  border-bottom: 1px solid #eef0f3;
+  background: #fff;
 }
 
-.mobile-sidebar-title {
-  margin: 0;
-  font-size: 16px;
-  font-weight: 600;
-  color: #303133;
-  flex: 1;
-}
-
-.mobile-sidebar-close-btn {
-  flex-shrink: 0;
-  margin-left: 12px;
-  width: 32px;
-  height: 32px;
-  padding: 0;
+.sidebar-brand {
   display: flex;
   align-items: center;
-  justify-content: center;
+  gap: 10px;
+  min-width: 0;
 }
 
-.el-aside {
-  background: linear-gradient(180deg, #ffffff 0%, #f8f9fa 100%);
-  border-right: 1px solid #e4e7ed;
-  z-index: 1000;
-  box-shadow: 2px 0 8px rgba(0, 0, 0, 0.04);
-  transition: all 0.3s ease;
+.brand-icon {
+  font-size: 22px;
+  color: var(--el-color-primary);
+  flex-shrink: 0;
+}
+
+.brand-text {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.brand-title {
+  font-size: 15px;
+  font-weight: 600;
+  color: #1f2329;
+  line-height: 1.3;
+}
+
+.brand-subtitle {
+  font-size: 12px;
+  color: #8f959e;
+  margin-top: 2px;
+}
+
+.sidebar-close-btn {
+  flex-shrink: 0;
+  margin-left: 8px;
+}
+
+.sidebar-search {
+  padding: 10px 12px;
+  flex-shrink: 0;
+  background: #fff;
+  border-bottom: 1px solid #eef0f3;
+}
+
+.sidebar-search :deep(.el-input__wrapper) {
+  border-radius: 8px;
+  box-shadow: 0 0 0 1px #dcdfe6 inset;
+  transition: box-shadow 0.2s ease;
+}
+
+.sidebar-search :deep(.el-input__wrapper.is-focus) {
+  box-shadow: 0 0 0 1px var(--el-color-primary) inset;
+}
+
+.sidebar-content {
+  flex: 1;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding-bottom: 16px;
+  scrollbar-width: thin;
+  scrollbar-color: #dcdfe6 transparent;
+}
+
+.sidebar-content::-webkit-scrollbar {
+  width: 4px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb {
+  background: #dcdfe6;
+  border-radius: 4px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb:hover {
+  background: #c0c4cc;
+}
+
+.sidebar-error {
+  padding: 32px 16px;
+}
+
+.sidebar-empty {
+  padding: 24px 0;
 }
 
 @media (max-width: 768px) {
@@ -4103,94 +2417,169 @@ const handleExportSelected = async () => {
     height: 100vh;
     width: 100%;
     z-index: 2000;
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-  }
-
-  .sidebar .menu-vertical {
-    flex: 1;
-    overflow-y: auto;
-    overflow-x: hidden;
   }
 }
 
 .menu-vertical {
-  height: 100%;
   background: transparent;
   border: none;
+  padding: 4px 0;
 }
 
-.menu-vertical .el-menu-item {
+.menu-vertical :deep(.el-menu-item) {
+  height: 40px;
+  line-height: 40px;
   border-radius: 8px;
-  margin: 4px 8px;
-  transition: all 0.3s ease;
+  margin: 2px 8px;
+  padding: 0 10px !important;
+  transition: background-color 0.2s ease, color 0.2s ease;
   position: relative;
+}
+
+.menu-item-inner {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  min-width: 0;
+}
+
+.menu-item-icon {
+  font-size: 16px;
+  flex-shrink: 0;
+}
+
+.menu-item-icon.folder {
+  color: #e6a23c;
+}
+
+.menu-item-icon.api {
+  color: #409eff;
+}
+
+.menu-item-label {
+  flex: 1;
+  min-width: 0;
   overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 13px;
+  color: #303133;
 }
 
-.menu-vertical .el-menu-item::before {
-  content: "";
-  position: absolute;
-  left: 0;
-  top: 0;
-  height: 100%;
-  width: 3px;
-  background: var(--el-color-primary);
-  transform: scaleY(0);
-  transition: transform 0.3s ease;
+.menu-item-count {
+  flex-shrink: 0;
+  font-size: 11px;
+  color: #909399;
+  background: #eef0f3;
+  padding: 1px 6px;
+  border-radius: 10px;
+  line-height: 16px;
 }
 
-.menu-vertical .el-menu-item:hover {
-  background-color: #f0f9ff;
-  transform: translateX(4px);
-  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+.menu-item-arrow {
+  flex-shrink: 0;
+  font-size: 12px;
+  color: #c0c4cc;
+  transition: transform 0.2s ease, color 0.2s ease;
 }
 
-.menu-vertical .el-menu-item:hover::before {
-  transform: scaleY(1);
-}
-
-.menu-vertical .el-menu-item.is-active {
-  background: linear-gradient(90deg, #ecf5ff 0%, #f0f9ff 100%);
+.menu-folder-item:hover .menu-item-arrow {
   color: var(--el-color-primary);
-  font-weight: 600;
+  transform: translateX(2px);
 }
 
-.menu-vertical .el-menu-item.is-active::before {
-  transform: scaleY(1);
-}
-
-/* 下载按钮样式 */
-.download-header {
-  position: fixed;
-  top: 20px;
-  right: 20px;
-  z-index: 1000;
-}
-
-.download-header .el-button {
-  box-shadow: 0 2px 12px rgba(64, 158, 255, 0.3);
-  transition: all 0.3s ease;
-  border-radius: 8px;
+.menu-folder-item :deep(.menu-item-label) {
   font-weight: 500;
 }
 
-.download-header .el-button:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 16px rgba(64, 158, 255, 0.4);
+.menu-vertical :deep(.menu-section-item) {
+  height: 32px !important;
+  line-height: 32px !important;
+  margin-top: 4px !important;
+  cursor: default !important;
+  opacity: 1 !important;
 }
 
-@media (max-width: 768px) {
-  .download-header {
-    top: 10px;
-    right: 10px;
-  }
+.menu-vertical :deep(.menu-section-item:hover) {
+  background: transparent !important;
+}
 
-  .download-header .el-button {
-    padding: 8px 12px;
-    font-size: 12px;
-  }
+.menu-vertical :deep(.menu-section-item::before) {
+  display: none !important;
+}
+
+.menu-section-label {
+  font-size: 11px;
+  font-weight: 600;
+  color: #909399;
+  letter-spacing: 0.5px;
+}
+
+.menu-vertical :deep(.el-menu-item:hover) {
+  background-color: #eef2ff;
+}
+
+.menu-vertical :deep(.el-menu-item.is-active) {
+  background-color: #e8f0fe;
+  color: var(--el-color-primary);
+}
+
+.menu-vertical :deep(.el-menu-item.is-active)::before {
+  content: "";
+  position: absolute;
+  left: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 3px;
+  height: 18px;
+  background: var(--el-color-primary);
+  border-radius: 0 2px 2px 0;
+}
+
+.menu-vertical :deep(.menu-api-item.is-active .menu-item-label) {
+  color: var(--el-color-primary);
+  font-weight: 500;
+}
+
+.menu-vertical :deep(.menu-api-item.is-active .menu-item-icon) {
+  color: var(--el-color-primary);
+}
+
+.main-content {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  padding: 0 !important;
+}
+
+.main-toolbar {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  padding: 12px 20px;
+  flex-shrink: 0;
+  border-bottom: 1px solid #eef0f3;
+  background: #fff;
+}
+
+.main-tabs {
+  flex: 1;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+}
+
+.main-tabs :deep(.el-tabs__header) {
+  margin: 0;
+  padding: 0 20px;
+  background: #fff;
+}
+
+.main-tabs :deep(.el-tabs__content) {
+  flex: 1;
+  overflow-y: auto;
+  padding: 0;
 }
 
 .api-detail {
@@ -4199,9 +2588,14 @@ const handleExportSelected = async () => {
   animation: fadeIn 0.5s ease;
 }
 
+.basic-type-display {
+  color: #606266;
+  margin-bottom: 16px;
+  font-size: 14px;
+}
+
 /* README引导页样式 */
 .readme-guide {
-  max-width: 1200px;
   margin: 0 auto;
   padding: 20px;
   animation: fadeIn 0.5s ease;
@@ -4516,165 +2910,107 @@ h4 {
 }
 
 /* 目录式导航样式 */
-/* 搜索框样式 */
-.search-input {
-  padding: 12px 8px;
-  border-radius: 8px;
-  transition: all 0.3s ease;
-}
-
-.search-input :deep(.el-input__wrapper) {
-  border-radius: 8px;
-  transition: all 0.3s ease;
-}
-
-.search-input :deep(.el-input__wrapper.is-focus) {
-  border-color: var(--el-color-primary);
-}
-
 .breadcrumb-nav {
-  margin: 12px 8px;
-  padding: 12px;
-  background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
+  margin: 8px 8px 4px;
+  padding: 10px 12px;
+  background: #fff;
   border-radius: 8px;
-  border: 1px solid #e4e7ed;
-  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
+  border: 1px solid #eef0f3;
 }
 
-.breadcrumb-buttons {
+.breadcrumb-toolbar {
   display: flex;
-  gap: 8px;
+  gap: 4px;
   margin-bottom: 8px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid #f0f2f5;
 }
 
-.breadcrumb-button {
-  flex: 1;
-  text-align: left;
-  padding: 10px;
-  transition: all 0.2s ease;
-}
-
-.breadcrumb-button:hover {
-  background-color: #ecf5ff;
-  color: var(--el-color-primary);
+.breadcrumb-btn {
+  font-size: 13px;
+  padding: 4px 8px;
+  height: auto;
 }
 
 .breadcrumb-path {
-  margin-top: 8px;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 2px;
   font-size: 12px;
+  line-height: 1.6;
+}
+
+.breadcrumb-tag {
   color: #606266;
-  padding: 5px 0;
-}
-
-.breadcrumb-item {
-  color: var(--el-color-primary);
-}
-
-.breadcrumb-separator {
-  color: #909399;
-  margin: 0 4px;
-}
-
-.breadcrumb-home {
-  font-weight: 600;
+  padding: 1px 4px;
+  border-radius: 4px;
 }
 
 .breadcrumb-clickable {
   cursor: pointer;
-  transition: all 0.2s ease;
-  padding: 2px 4px;
-  border-radius: 4px;
-  text-decoration: underline;
+  color: var(--el-color-primary);
+  transition: background-color 0.2s ease;
 }
 
 .breadcrumb-clickable:hover {
   background-color: #ecf5ff;
-  color: var(--el-color-primary);
-  transform: translateY(-1px);
 }
 
-.group-item {
-  display: flex;
-  align-items: center;
+.breadcrumb-current {
+  color: #303133;
+  font-weight: 500;
 }
 
-.group-item .folder-icon {
-  margin-right: 8px;
-  font-size: 18px;
-  transition: transform 0.3s ease;
-}
-
-.group-item:hover .folder-icon {
-  transform: scale(1.1);
-}
-
-.group-item .arrow-icon {
-  margin-left: auto;
-  color: var(--el-color-primary);
-  font-weight: bold;
-  transition: transform 0.3s ease;
-  opacity: 0.6;
-}
-
-.group-item:hover .arrow-icon {
-  transform: translateX(4px);
-  opacity: 1;
-}
-
-.final-group {
-  color: #606266 !important;
-  font-weight: 600;
-  cursor: pointer;
-}
-
-.final-group:hover {
-  background-color: #f5f7fa;
-  color: var(--el-color-primary) !important;
+.breadcrumb-chevron {
+  font-size: 10px;
+  color: #c0c4cc;
+  flex-shrink: 0;
 }
 
 .common-info {
-  max-width: 1200px;
   margin: 0 auto;
   padding: 20px;
   animation: fadeIn 0.5s ease;
 }
 
 /* 导出模块样式 */
+.export-drawer :deep(.el-drawer__body) {
+  padding: 0;
+  overflow-y: auto;
+}
+
 .export-module {
-  max-width: 1200px;
-  margin: 0 auto;
-  padding: 20px;
-  animation: fadeIn 0.5s ease;
-}
-
-.export-module-header {
-  margin-bottom: 30px;
-  text-align: center;
-}
-
-.export-module-header h2 {
-  margin-bottom: 10px;
-  color: #303133;
+  padding: 0 20px 24px;
 }
 
 .export-description {
   color: #909399;
-  font-size: 14px;
-}
-
-/* 快速导出卡片 */
-.export-quick-actions {
-  margin-bottom: 30px;
+  font-size: 13px;
+  margin: 0 0 16px;
+  line-height: 1.5;
 }
 
 .quick-export-card {
-  border-radius: 12px;
-  transition: all 0.3s ease;
+  border-radius: 8px;
+  margin-bottom: 20px;
+  border: 1px solid #eef0f3;
 }
 
-.quick-export-card:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.12);
+.quick-export-card :deep(.el-card__header) {
+  padding: 12px 16px;
+  background: #fafbfc;
+  border-bottom: 1px solid #eef0f3;
+}
+
+.quick-export-card :deep(.el-card__body) {
+  padding: 16px;
+}
+
+.common-info {
+  margin: 0 auto;
+  padding: 20px;
+  animation: fadeIn 0.5s ease;
 }
 
 .card-header {
@@ -4714,10 +3050,10 @@ h4 {
 }
 
 .export-content {
-  background: #ffffff;
+  background: #fafbfc;
   border-radius: 8px;
-  padding: 20px;
-  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.08);
+  padding: 16px;
+  border: 1px solid #eef0f3;
 }
 
 /* 导出对话框样式 */
@@ -4754,13 +3090,14 @@ h4 {
 }
 
 .export-api-list {
-  max-height: 500px;
+  max-height: calc(100vh - 420px);
+  min-height: 200px;
   overflow-y: auto;
   border: 1px solid #e4e7ed;
   border-radius: 8px;
-  padding: 15px;
-  margin-bottom: 20px;
-  background: #fafafa;
+  padding: 12px;
+  margin-bottom: 16px;
+  background: #fff;
 }
 
 .export-api-item {
@@ -4839,372 +3176,6 @@ h4 {
   transition: none !important;
 }
 
-/* 调试模块样式 - POSTMAN风格 */
-.debug-module {
-  height: calc(100vh - 120px);
-  display: flex;
-  flex-direction: column;
-  background: #f7f7f7;
-}
-
-.debug-layout {
-  display: flex;
-  height: 100%;
-  gap: 1px;
-  background: #e0e0e0;
-  overflow: hidden;
-}
-
-/* 左侧请求面板 */
-.debug-request-panel {
-  flex: 1;
-  min-width: 400px;
-  background: #ffffff;
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-}
-
-/* 右侧响应面板 */
-.debug-response-panel {
-  flex: 1;
-  min-width: 400px;
-  background: #ffffff;
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-  border-left: 1px solid #e0e0e0;
-}
-
-/* 面板头部 */
-.debug-panel-header {
-  height: 48px;
-  background: #f7f7f7;
-  border-bottom: 1px solid #e0e0e0;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 0 16px;
-  font-weight: 600;
-  font-size: 13px;
-  color: #303133;
-}
-
-.panel-title {
-  color: #303133;
-  font-weight: 600;
-}
-
-.response-time {
-  font-size: 12px;
-  color: #909399;
-  font-weight: normal;
-}
-
-/* 面板内容 */
-.debug-panel-content {
-  flex: 1;
-  overflow-y: auto;
-  padding: 16px;
-}
-
-/* URL配置区域 */
-.debug-url-section {
-  margin-bottom: 16px;
-}
-
-.debug-label {
-  font-size: 12px;
-  color: #606266;
-  margin-bottom: 8px;
-  font-weight: 500;
-}
-
-.debug-url-input {
-  width: 100%;
-}
-
-/* 折叠面板样式 */
-.debug-collapse {
-  margin-bottom: 16px;
-  border: none;
-}
-
-.debug-collapse :deep(.el-collapse-item__header) {
-  background: #f7f7f7;
-  border: 1px solid #e0e0e0;
-  border-radius: 4px;
-  padding: 8px 12px;
-  font-size: 13px;
-  font-weight: 500;
-  color: #303133;
-}
-
-.debug-collapse :deep(.el-collapse-item__content) {
-  padding: 12px;
-  background: #ffffff;
-}
-
-/* 变量管理区域 */
-.variable-section {
-  padding: 8px 0;
-}
-
-/* 表单区域 */
-.debug-form-section {
-  margin-top: 16px;
-}
-
-.debug-form-section :deep(.el-form-item__label) {
-  font-size: 12px;
-  color: #606266;
-  font-weight: 500;
-  padding-bottom: 4px;
-}
-
-.debug-param-item {
-  margin-bottom: 16px;
-}
-
-.debug-param-item :deep(.el-form-item__label) {
-  font-size: 13px;
-  color: #303133;
-}
-
-.param-desc {
-  margin-top: 6px;
-}
-
-.param-desc-text {
-  color: #909399;
-  font-size: 12px;
-  line-height: 1.5;
-}
-
-/* JSON模式样式 */
-.json-mode-container {
-  margin-top: 8px;
-}
-
-.json-mode-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 8px;
-  padding: 8px 0;
-}
-
-.json-mode-tip {
-  font-size: 12px;
-  color: #909399;
-  flex: 1;
-}
-
-.json-params-input {
-  font-family: "Consolas", "Monaco", "Courier New", monospace;
-  font-size: 13px;
-  line-height: 1.6;
-}
-
-.json-params-input :deep(.el-textarea__inner) {
-  font-family: "Consolas", "Monaco", "Courier New", monospace;
-  font-size: 13px;
-  line-height: 1.6;
-  background: #fafafa;
-  border: 1px solid #e0e0e0;
-  border-radius: 4px;
-  padding: 12px;
-}
-
-.json-params-input :deep(.el-textarea__inner):focus {
-  border-color: #409eff;
-  background: #ffffff;
-}
-
-.json-params-error {
-  margin-top: 8px;
-  padding: 8px 12px;
-  background: #fef0f0;
-  border: 1px solid #fde2e2;
-  border-radius: 4px;
-  color: #f56c6c;
-  font-size: 12px;
-}
-
-/* 发送按钮 */
-.debug-send-button {
-  background: #ff6c37;
-  border-color: #ff6c37;
-  font-weight: 500;
-  padding: 10px 24px;
-}
-
-.debug-send-button:hover {
-  background: #ff5722;
-  border-color: #ff5722;
-}
-
-/* 响应结果区域 */
-.debug-empty-state {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  height: 100%;
-  min-height: 300px;
-}
-
-.debug-result-tabs {
-  height: 100%;
-}
-
-.debug-result-tabs :deep(.el-tabs__header) {
-  margin: 0 0 12px 0;
-  border-bottom: 1px solid #e0e0e0;
-}
-
-.debug-result-tabs :deep(.el-tabs__item) {
-  font-size: 13px;
-  padding: 0 16px;
-  height: 40px;
-  line-height: 40px;
-}
-
-.debug-result-container {
-  background: #ffffff;
-  border: 1px solid #e0e0e0;
-  border-radius: 4px;
-  overflow: hidden;
-}
-
-.debug-result-header {
-  background: #f7f7f7;
-  padding: 8px 12px;
-  border-bottom: 1px solid #e0e0e0;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-}
-
-.result-status {
-  font-size: 12px;
-  font-weight: 500;
-}
-
-.result-status.status-success {
-  color: #67c23a;
-}
-
-.result-status.status-warning {
-  color: #e6a23c;
-}
-
-.result-status.status-error {
-  color: #f56c6c;
-}
-
-.debug-result-content {
-  background: #ffffff;
-  padding: 16px;
-  margin: 0;
-  overflow-x: auto;
-  height: calc(100vh - 320px);
-  overflow-y: auto;
-  font-family: "Consolas", "Monaco", "Courier New", monospace;
-  font-size: 13px;
-  line-height: 1.6;
-  color: #303133;
-  border: none;
-  border-radius: 0;
-}
-
-/* 日志区域 */
-.debug-log-container {
-  height: calc(100vh - 300px);
-  overflow-y: auto;
-  background: #ffffff;
-  border-radius: 4px;
-  padding: 12px;
-}
-
-.log-item {
-  padding: 8px 12px;
-  margin-bottom: 6px;
-  border-radius: 4px;
-  font-family: "Consolas", "Monaco", "Courier New", monospace;
-  font-size: 12px;
-  line-height: 1.6;
-  border-left: 3px solid transparent;
-}
-
-.log-item.info {
-  background: #f0f9ff;
-  color: #303133;
-  border-left-color: #409eff;
-}
-
-.log-item.success {
-  background: #f0f9ff;
-  color: #67c23a;
-  border-left-color: #67c23a;
-}
-
-.log-item.error {
-  background: #fef0f0;
-  color: #f56c6c;
-  border-left-color: #f56c6c;
-}
-
-.log-time {
-  color: #909399;
-  margin-right: 8px;
-  font-size: 11px;
-}
-
-.log-type {
-  font-weight: 600;
-  margin-right: 8px;
-  font-size: 11px;
-}
-
-.log-message {
-  color: inherit;
-  word-break: break-all;
-}
-
-/* 响应式设计 */
-@media (max-width: 1200px) {
-  .debug-layout {
-    flex-direction: column;
-  }
-
-  .debug-request-panel,
-  .debug-response-panel {
-    min-width: 100%;
-    max-height: 50%;
-  }
-
-  .debug-response-panel {
-    border-left: none;
-    border-top: 1px solid #e0e0e0;
-  }
-}
-
-@media (max-width: 768px) {
-  .debug-module {
-    height: auto;
-    min-height: calc(100vh - 120px);
-  }
-
-  .debug-panel-content {
-    padding: 12px;
-  }
-
-  .debug-result-content,
-  .debug-log-container {
-    max-height: 400px;
-  }
-}
-
 :deep(.el-table__inner-wrapper:before) {
   background-color: transparent;
 }