api-dot.js

/**
 * API-DOT - API Detection and Optimization Tool
 * 用于扫描项目中的API端点并进行连接测试
 */

const ApiDot = (() => {
    // 配置项
    const config = {
        timeout: 3000,         // API请求超时时间（毫秒）
        maxDepth: 3,          // 文件扫描最大深度
        mockFallback: true,   // 连接失败时是否使用模拟数据
        forceMock: false,     // 强制使用模拟数据
        autoDetect: true,     // 是否自动检测当前工作目录
        projectType: null,    // 项目类型（react、vue、angular等）
        includeExtensions: [".js", ".jsx", ".ts", ".tsx", ".html", ".vue", ".php", ".py", ".java", ".cs", ".go"], // 要扫描的文件扩展名
        excludePatterns: ["node_modules", ".git", "dist", "build", ".cache"], // 排除的目录
        theme: "dark",        // 主题模式
        testMethod: "head",   // API测试方法 
        exportFormat: "json", // 默认导出格式
        autoExport: false,    // 是否自动导出
        autoTest: true,       // 是否自动测试API
        apiPatterns: [         // API调用模式的正则表达式
            // JavaScript/TypeScript Fetch API
            { pattern: /fetch\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /fetch\(['"](https?:\/\/[^'"]+)['"].*?method:\s*['"]([A-Z]+)['"]/, group: 1, methodGroup: 2, language: 'js' },
            { pattern: /fetch\(['"](https?:\/\/[^'"]+)['"].*?method:\s*[^'"]([A-Z]+)[^'"]/, group: 1, methodGroup: 2, language: 'js' },
            
            // Axios
            { pattern: /axios\.(get|post|put|delete|patch)\(['"](https?:\/\/[^'"]+)['"]/, group: 2, methodGroup: 1, language: 'js' },
            { pattern: /axios\(['"](https?:\/\/[^'"]+)['"].*?method:\s*['"]([A-Z]+)['"]/, group: 1, methodGroup: 2, language: 'js' },
            { pattern: /axios\(\{[^}]*url:\s*['"]([^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /axios\(\{[^}]*url:\s*['"]([^'"]+)['"].*?method:\s*['"]([A-Z]+)['"]/, group: 1, methodGroup: 2, language: 'js' },
            
            // jQuery AJAX
            { pattern: /\$\.ajax\(\{[^}]*url:\s*['"]([^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /\$\.ajax\(\{[^}]*url:\s*['"]([^'"]+)['"].*?type:\s*['"]([A-Z]+)['"]/, group: 1, methodGroup: 2, language: 'js' },
            { pattern: /\$\.ajax\(\{[^}]*url:\s*['"]([^'"]+)['"].*?method:\s*['"]([A-Z]+)['"]/, group: 1, methodGroup: 2, language: 'js' },
            { pattern: /\$\.get\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /\$\.post\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'POST', language: 'js' },
            
            // XMLHttpRequest
            { pattern: /new\s+XMLHttpRequest\(\)[^}]*\.open\(['"](GET|POST|PUT|DELETE|PATCH)['"],\s*['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'js' },
            
            // React/Next.js
            { pattern: /getServerSideProps[^{]*\{[^}]*fetch\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /useSWR\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            { pattern: /useQuery\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            
            // Angular HttpClient
            { pattern: /http\.(get|post|put|delete|patch)\(['"](https?:\/\/[^'"]+)['"]/, group: 2, methodGroup: 1, language: 'js' },
            { pattern: /httpClient\.(get|post|put|delete|patch)\(['"](https?:\/\/[^'"]+)['"]/, group: 2, methodGroup: 1, language: 'js' },
            
            // Vue/Nuxt
            { pattern: /this\.\$axios\.(get|post|put|delete|patch)\(['"](https?:\/\/[^'"]+)['"]/, group: 2, methodGroup: 1, language: 'js' },
            { pattern: /\$fetch\(['"](https?:\/\/[^'"]+)['"]/, group: 1, method: 'GET', language: 'js' },
            
            // GraphQL
            { pattern: /useQuery\(\s*\(?gql`[^`]*`[^)]*\)/, isGraphQL: true, method: 'POST', language: 'js' },
            { pattern: /useMutation\(\s*\(?gql`[^`]*`[^)]*\)/, isGraphQL: true, method: 'POST', language: 'js' },
            { pattern: /(query|mutation)\s+\w+\s*\([^)]*\)\s*\{/, isGraphQL: true, method: 'POST', language: 'js' },
            
            // Python requests
            { pattern: /requests\.(get|post|put|delete|patch)\(['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'py' },
            { pattern: /requests\.request\(['"]([A-Z]+)['"],\s*['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'py' },
            
            // PHP curl
            { pattern: /curl_init\(['"]([^'"]+)['"]/, group: 1, method: 'GET', language: 'php' },
            { pattern: /curl_setopt\(\$ch,\s*CURLOPT_URL,\s*['"]([^'"]+)['"]/, group: 1, method: 'GET', language: 'php' },
            
            // C# HttpClient
            { pattern: /HttpClient\(\).*(GetAsync|GetStringAsync)\(['"]([^'"]+)['"]/, group: 2, method: 'GET', language: 'cs' },
            { pattern: /HttpClient\(\).*(PostAsync|PutAsync|DeleteAsync)\(['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'cs' },
            
            // Go http
            { pattern: /http\.(Get|Post|Put|Delete)\(['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'go' },
            { pattern: /http\.NewRequest\(['"]([A-Z]+)['"],\s*['"]([^'"]+)['"]/, group: 2, methodGroup: 1, language: 'go' },
            
            // REST API Controllers
            { pattern: /\@(Get|Post|Put|Delete|Patch)\(['"]([^'"]+)['"]/, group: 2, methodGroup: 1, isController: true, language: 'ts' },
            { pattern: /\@RequestMapping\(.*value\s*=\s*['"]([^'"]+)['"].*method\s*=\s*RequestMethod\.([A-Z]+)/, group: 1, methodGroup: 2, isController: true, language: 'java' },
            
            // Base URLs and API configuration
            { pattern: /baseURL:\s*['"]([^'"]+)['"]/, group: 1, isConfig: true, language: 'js' },
            { pattern: /BASE_URL\s*=\s*['"]([^'"]+)['"]/, group: 1, isConfig: true, language: 'js' },
            { pattern: /API_URL\s*=\s*['"]([^'"]+)['"]/, group: 1, isConfig: true, language: 'js' },
            { pattern: /env\.([^\s.]+_URL)\s*=\s*['"]([^'"]+)['"]/, group: 2, isConfig: true, language: 'js' },
            
            // Relative endpoints
            { pattern: /\.(get|post|put|delete|patch)\(['"]([^\s'"]+)['"]/, group: 2, methodGroup: 1, isRelative: true, language: 'js' },
            { pattern: /\/api\/([\w-\/]+)/, group: 0, isRelative: true, language: 'js' }
        ],
        apiBaseUrls: [],       // 扫描到的API基础URL
        issuePatterns: [      // 检测常见问题的模式
            {
                pattern: /http:\/\/(?!localhost|127\.0\.0\.1)/,
                issue: {
                    type: '安全问题',
                    severity: 'high',
                    description: '使用不安全的HTTP协议',
                    solution: '将HTTP URL替换为HTTPS URL以确保安全'
                }
            },
            {
                pattern: /"[^"]*token[^"]*":\s*"[^"]{5,}"/i,
                issue: {
                    type: '安全问题',
                    severity: 'high',
                    description: '发现硬编码的API令牌',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                }
            },
            {
                pattern: /fetch\([^\)]*\)(?!\s*\.then|\s*\.catch)/,
                issue: {
                    type: '质量问题',
                    severity: 'medium',
                    description: 'API调用缺少错误处理',
                    solution: '添加.then()和.catch()处理成功和错误情况'
                }
            },
            {
                pattern: /axios\([^\)]*\)(?!\s*\.then|\s*\.catch)/,
                issue: {
                    type: '质量问题',
                    severity: 'medium',
                    description: 'API调用缺少错误处理',
                    solution: '添加.then()和.catch()处理成功和错误情况'
                }
            },
            {
                pattern: /password["']?\s*:\s*["']([^"\']+)["']/i,
                issue: {
                    type: '安全问题',
                    severity: 'critical',
                    description: '发现硬编码的密码',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                }
            },
            {
                pattern: /api[_-]?key["']?\s*:\s*["']([^"\']{10,})["']/i,
                issue: {
                    type: '安全问题',
                    severity: 'high',
                    description: '发现硬编码的API Key',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                }
            },
            {
                pattern: /auth["']?\s*:\s*["']([^"\']+)["']/i,
                issue: {
                    type: '安全问题',
                    severity: 'high',
                    description: '发现硬编码的认证信息',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                }
            },
            {
                pattern: /cors/i,
                issue: {
                    type: '安全问题',
                    severity: 'medium',
                    description: '可能存在CORS问题',
                    solution: '检查CORS配置并确保安全'
                }
            },
            {
                pattern: /cache-control/i,
                issue: {
                    type: '性能问题',
                    severity: 'low',
                    description: '可能需要优化缓存控制',
                    solution: '添加合适的Cache-Control头以提高性能'
                }
            },
            {
                pattern: /try\s*{[^}]*}\s*catch\s*\([^)]*\)\s*{\s*}/,
                issue: {
                    type: '质量问题',
                    severity: 'medium',
                    description: '可能存在空的catch块',
                    solution: '在catch块中添加错误处理代码'
                }
            },
            {
                pattern: /Authorization:\s*["']?Bearer\s+([^\s"']+)/i,
                issue: {
                    type: '安全问题',
                    severity: 'high',
                    description: '发现硬编码的Bearer令牌',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                }
            },
            {
                pattern: /setTimeout\(\s*[^,]+,\s*(\d{5,})/,
                issue: {
                    type: '性能问题',
                    severity: 'medium',
                    description: '可能存在超时问题',
                    solution: '检查并优化超时时间'
                }
            },
            {
                pattern: /retries|retry/i,
                issue: {
                    type: '可靠性问题',
                    severity: 'info',
                    description: '可能需要重试机制',
                    solution: '添加重试机制以提高可靠性'
                }
            },
            {
                pattern: /url:\s*`/,
                issue: {
                    type: '安全问题',
                    severity: 'medium',
                    description: '可能存在URL注入风险',
                    solution: '检查并确保URL安全'
                }
            }
        ],
    };

    // 状态管理
    const state = {
        isScanning: false,    // 是否正在扫描
        projectDir: null,     // 项目目录句柄
        endpoints: [],        // 扫描到的API端点
        testResults: {        // 测试结果
            total: 0,
            passed: 0,
            failed: 0,
            pending: 0,
            startTime: null,
            endTime: null
        },
        logs: [],             // 日志信息
        servers: {            // 服务器状态管理
            backend: {
                running: false,
                url: 'http://localhost:8080',
                name: '后端',
                process: null,
                startCommand: '',
                lastCheck: null
            },
            frontend: {
                running: false,
                url: 'http://localhost:3000',
                name: '前端',
                process: null,
                startCommand: '',
                lastCheck: null
            }
        }
    };

    // 语言模块
    const langModule = {
        // 当前语言
        current: localStorage.getItem('apidot-language') || 'zh',
        
        // 翻译字典
        translations: {
            'zh': {
                'dashboard': '总览',
                'dashboard-title': 'API-DOT',
                'endpoints': 'API端点',
                'endpoints-title': 'API端点列表',
                'endpoints-list': '所有API端点',
                'issues': '问题诊断',
                'issues-title': '问题诊断',
                'issues-list': '检测到的问题',
                'logs': '日志记录',
                'logs-title': '日志记录',
                'logs-list': '日志列表',
                'settings': '设置',
                'settings-title': '设置',
                'general-settings': '通用设置',
                'scan-settings': '扫描设置',
                'export-settings': '导出设置',
                'test-settings': '测试设置',
                'theme': '主题',
                'language-setting': '语言',
                'scan-depth': '扫描深度',
                'request-timeout': '请求超时(毫秒)',
                'exclude-patterns': '排除模式',
                'export-format': '默认导出格式',
                'auto-export': '自动导出',
                'auto-test': '自动测试API连接',
                'test-method': '测试方法',
                'save-settings': '保存设置',
                'reset-settings': '重置设置',
                'scan-button': '扫描项目',
                'total-endpoints': 'API端点总数',
                'total-issues': '发现问题总数',
                'health-score': 'API健康评分',
                'server-status': '服务器状态',
                'backend-server': '后端服务器',
                'frontend-server': '前端服务器',
                'check-status': '检查状态',
                'start-server': '启动',
                'restart-server': '重启',
                'stop-server': '停止',
                'use-mock-data': '使用模拟数据',
                'export-json': '导出报告 (JSON)',
                'export-txt': '导出报告 (TXT)',
                'recent-endpoints': '最近扫描的API端点',
                'endpoint-url': 'URL',
                'endpoint-method': '方法',
                'endpoint-status': '状态',
                'endpoint-issues': '问题',
                'endpoint-actions': '操作',
                'endpoint-details': '端点详情',
                'endpoint-issues-list': '问题列表',
                'issue-type': '问题类型',
                'issue-severity': '严重程度',
                'issue-endpoint': '相关端点',
                'issue-solution': '解决方案',
                'log-time': '日志时间',
                'log-content': '日志内容',
                'language': 'EN/中文',
                'mock-toggle': '模拟数据模式',
                'file-drop-hint': '拖放项目文件夹或点击选择',
                'file-drop-sub': '我们将扫描项目中的API端点',
                'view-details': '查看详情',
                'api-test-result': 'API测试结果',
                'scanning': '正在扫描...',
                'test-result': '测试结果',
                'not-found': '未找到',
                'loading': '加载中...',
                'mock-data-desc': '启用后将使用模拟数据进行测试，关闭则使用真实API数据',
                'auto-detect': '自动检测项目',
                'auto-detect-desc': '启动时自动检测并分析当前目录下的项目结构',
                'update-url': '更新'
            },
            'en': {
                'dashboard': 'Dashboard',
                'dashboard-title': 'API-DOT',
                'endpoints': 'API Endpoints',
                'endpoints-title': 'API Endpoints List',
                'endpoints-list': 'All API Endpoints',
                'issues': 'Issues',
                'issues-title': 'Issue Diagnostics',
                'issues-list': 'Detected Issues',
                'logs': 'Logs',
                'logs-title': 'Log Records',
                'logs-list': 'Log List',
                'settings': 'Settings',
                'settings-title': 'Settings',
                'general-settings': 'General Settings',
                'scan-settings': 'Scan Settings',
                'export-settings': 'Export Settings',
                'test-settings': 'Test Settings',
                'theme': 'Theme',
                'language-setting': 'Language',
                'scan-depth': 'Scan Depth',
                'request-timeout': 'Request Timeout(ms)',
                'exclude-patterns': 'Exclude Patterns',
                'export-format': 'Default Export Format',
                'auto-export': 'Auto Export',
                'auto-test': 'Auto Test API Connection',
                'test-method': 'Test Method',
                'save-settings': 'Save Settings',
                'reset-settings': 'Reset Settings',
                'scan-button': 'Scan Project',
                'total-endpoints': 'Total API Endpoints',
                'total-issues': 'Total Issues Found',
                'health-score': 'API Health Score',
                'server-status': 'Server Status',
                'backend-server': 'Backend Server',
                'frontend-server': 'Frontend Server',
                'check-status': 'Check Status',
                'start-server': 'Start',
                'restart-server': 'Restart',
                'stop-server': 'Stop',
                'use-mock-data': 'Use Mock Data',
                'export-json': 'Export Report (JSON)',
                'export-txt': 'Export Report (TXT)',
                'recent-endpoints': 'Recently Scanned Endpoints',
                'endpoint-url': 'URL',
                'endpoint-method': 'Method',
                'endpoint-status': 'Status',
                'endpoint-issues': 'Issues',
                'endpoint-actions': 'Actions',
                'endpoint-details': 'Endpoint Details',
                'endpoint-issues-list': 'Issues List',
                'issue-type': 'Issue Type',
                'issue-severity': 'Severity',
                'issue-endpoint': 'Related Endpoint',
                'issue-solution': 'Solution',
                'log-time': 'Time',
                'log-content': 'Content',
                'language': '中文/EN',
                'mock-toggle': 'Mock Data Mode',
                'file-drop-hint': 'Drop project folder here or click to select',
                'file-drop-sub': 'We will scan your project for API endpoints',
                'view-details': 'View Details',
                'api-test-result': 'API Test Results',
                'scanning': 'Scanning...',
                'test-result': 'Test Result',
                'not-found': 'Not Found',
                'loading': 'Loading...',
                'mock-data-desc': 'When enabled, mock data will be used for testing. When disabled, real API data will be used.',
                'auto-detect': 'Auto Detect Project',
                'auto-detect-desc': 'Automatically detect and analyze project structure in current directory when started',
                'update-url': 'Update'
            }
        },
        
        // 切换语言
        switchTo: function(lang) {
            console.log('ApiDot.lang.switchTo:', lang);
            if (!this.translations[lang]) return;
            
            this.current = lang;
            localStorage.setItem('apidot-language', lang);
            
            try {
                // 更新所有标有data-lang-key属性的元素的文本内容
                const elements = document.querySelectorAll('[data-lang-key]');
                console.log(`Found ${elements.length} elements with data-lang-key attribute`);
                
                elements.forEach(element => {
                    const key = element.getAttribute('data-lang-key');
                    if (this.translations[lang] && this.translations[lang][key]) {
                        element.textContent = this.translations[lang][key];
                    } else {
                        console.warn(`No translation found for key: ${key} in language: ${lang}`);
                    }
                });
                
                // 更新语言切换按钮文本
                const langButton = document.getElementById('lang-text');
                if (langButton) {
                    const langText = lang === 'zh' ? 'EN/中文' : '中文/EN';
                    langButton.textContent = langText;
                }
            } catch (error) {
                console.error('Error switching language:', error);
            }
            
            // 更新语言切换状态
            if (typeof log === 'function') {
                log(`语言已切换为 ${lang === 'zh' ? '中文' : 'English'}`, 'info');
            }
        },
        
        // 初始化
        init: function() {
            console.log('Initializing language system with language:', this.current);
            // 添加语言切换按钮事件
            const langToggle = document.getElementById('lang-toggle');
            if (langToggle) {
                langToggle.addEventListener('click', () => {
                    const newLang = this.current === 'zh' ? 'en' : 'zh';
                    this.switchTo(newLang);
                });
                console.log('Language toggle button initialized');
            } else {
                console.error('Language toggle button not found');
            }
            
            // 应用当前语言
            setTimeout(() => {
                this.switchTo(this.current);
            }, 300);
        }
    };

    // 日志工具
    function log(message, type = 'info') {
        const logItem = {
            message,
            type,
            timestamp: new Date().toISOString()
        };
        state.logs.push(logItem);
        console.log(`[${type.toUpperCase()}] ${message}`);
        
        // 向UI发送日志
        if (window.updateLog) {
            window.updateLog(logItem);
        }
    }

    // 选择项目文件夹
    async function selectProjectFolder() {
        try {
            state.isScanning = true;
            log('请选择项目文件夹...', 'info');
            
            // 使用文件系统访问API
            state.projectDir = await window.showDirectoryPicker();
            log(`已选择文件夹: ${state.projectDir.name}`, 'success');
            
            // 开始扫描项目
            await scanProject();
        } catch (error) {
            // 如果用户取消选择或出现其他错误
            log(`无法访问项目文件夹: ${error.message}`, 'error');
            loadExampleData(); // 加载示例数据作为备选
        } finally {
            state.isScanning = false;
            updateUI();
        }
    }
    
    // 处理拖放的文件/文件夹
    async function handleDroppedFiles(files) {
        try {
            state.isScanning = true;
            log('正在处理拖放的文件...', 'info');
            
            if (files.length === 0) {
                throw new Error('未检测到文件');
            }
            
            // 检查拖放的是否是文件夹
            const items = [];
            for (let i = 0; i < files.length; i++) {
                if (files[i].webkitGetAsEntry) {
                    const entry = files[i].webkitGetAsEntry();
                    if (entry.isDirectory) {
                        items.push(entry);
                    }
                } else {
                    // 创建临时FileSystem对象来处理文件
                    const tmpDir = await navigator.storage.getDirectory();
                    for (const file of files) {
                        const newHandle = await tmpDir.getFileHandle(file.name, { create: true });
                        const writable = await newHandle.createWritable();
                        await writable.write(file);
                        await writable.close();
                        items.push(newHandle);
                    }
                }
            }
            
            if (items.length > 0) {
                log(`已检测到 ${items.length} 个文件/文件夹`, 'success');
                
                // 如果拖放的是文件夹，尝试使用文件系统API访问
                try {
                    state.projectDir = await window.showDirectoryPicker();
                    log(`已选择文件夹: ${state.projectDir.name}`, 'success');
                    await scanProject();
                } catch (error) {
                    // 如果无法使用文件系统API，直接解析文件内容
                    state.endpoints = [];
                    
                    // 处理文件
                    for (const file of files) {
                        try {
                            const content = await file.text();
                            const fileExt = '.' + file.name.split('.').pop().toLowerCase();
                            
                            if (config.includeExtensions.includes(fileExt)) {
                                log(`正在解析文件: ${file.name}`, 'info');
                                analyzeFileContent(content, file.name, getLanguageFromExt(fileExt));
                            }
                        } catch (e) {
                            log(`无法读取文件 ${file.name}: ${e.message}`, 'warning');
                        }
                    }
                    
                    // 规范化和去重API端点
                    normalizeEndpoints();
                    
                    // 测试API连接
                    await testApiConnections();
                    
                    log(`扫描完成！发现 ${state.endpoints.length} 个API端点`, 'success');
                }
            } else {
                throw new Error('未检测到有效的文件或文件夹');
            }
        } catch (error) {
            log(`处理文件失败: ${error.message}`, 'error');
            loadExampleData(); // 加载示例数据作为备选
        } finally {
            state.isScanning = false;
            updateUI();
        }
    }
    
    // 自动扫描当前目录
    async function autoScanCurrentDirectory() {
        try {
            // 获取当前目录URL信息
            const currentUrl = window.location.href;
            log(`正在自动扫描当前目录: ${currentUrl}`, 'info');
            
            // 先查找常见的API文件
            const rootDir = currentUrl.substring(0, currentUrl.lastIndexOf('/'));
            log(`探测项目根目录: ${rootDir}`, 'info');
            
            // 在页面加载时直接触发文件选择对话框(更好的用户体验)
            log('请选择项目根目录...', 'info');
            try {
                await selectProjectFolder();
            } catch (e) {
                // 如果自动选择失败，使用示例数据
                log('自动扫描失败，使用示例数据', 'warning');
                loadExampleData();
            }
        } catch (error) {
            log(`自动扫描失败: ${error.message}`, 'error');
            loadExampleData();
        }
    }
    
    // 扫描项目文件
    async function scanProject() {
        if (!state.projectDir) return;
        
        state.endpoints = [];
        state.testResults = {
            total: 0,
            passed: 0,
            failed: 0,
            pending: 0,
            startTime: new Date(),
            endTime: null
        };
        
        log('开始扫描项目文件...', 'info');
        
        try {
            // 扫描文件
            await scanDirectory(state.projectDir, 0);
            
            // 规范化和去重API端点
            normalizeEndpoints();
            
            // 测试API连接
            await testApiConnections();
            
            state.testResults.endTime = new Date();
            const duration = (state.testResults.endTime - state.testResults.startTime) / 1000;
            
            log(`扫描完成！发现 ${state.endpoints.length} 个API端点，用时 ${duration} 秒`, 'success');
        } catch (error) {
            log(`扫描过程中出错: ${error.message}`, 'error');
            loadExampleData(); // 加载示例数据作为备选
        }
    }
    
    // 递归扫描目录
    async function scanDirectory(dirHandle, depth) {
        if (depth > config.maxDepth) return;
        
        for await (const entry of dirHandle.values()) {
            try {
                if (entry.kind === 'directory') {
                    // 跳过node_modules和.git等目录
                    if (config.excludePatterns.includes(entry.name)) {
                        continue;
                    }
                    
                    const subDirHandle = await dirHandle.getDirectoryHandle(entry.name);
                    await scanDirectory(subDirHandle, depth + 1);
                } else if (entry.kind === 'file') {
                    // 检查文件扩展名
                    const fileName = entry.name.toLowerCase();
                    const fileExt = '.' + fileName.split('.').pop();
                    
                    if (config.includeExtensions.includes(fileExt)) {
                        await scanFile(entry, dirHandle, getLanguageFromExt(fileExt));
                    }
                }
            } catch (error) {
                log(`无法处理 ${entry.name}: ${error.message}`, 'warning');
            }
        }
    }
    
    // 根据扩展名判断语言
    function getLanguageFromExt(ext) {
        const langMap = {
            '.js': 'js',
            '.jsx': 'js',
            '.ts': 'js',
            '.tsx': 'js',
            '.vue': 'js',
            '.html': 'html',
            '.php': 'php',
            '.py': 'py',
            '.java': 'java',
            '.cs': 'cs',
            '.go': 'go'
        };
        return langMap[ext] || 'js'; // 默认为js
    }
    
    // 扫描单个文件
    async function scanFile(fileEntry, dirHandle, language) {
        try {
            const fileHandle = await dirHandle.getFileHandle(fileEntry.name);
            const file = await fileHandle.getFile();
            const content = await file.text();
            
            // 分析文件内容
            analyzeFileContent(content, file.name, language);
        } catch (error) {
            log(`无法读取文件 ${fileEntry.name}: ${error.message}`, 'warning');
        }
    }
    
    // 分析文件内容，提取API端点
    function analyzeFileContent(content, fileName, language) {
        // 首先查找API基础URL配置
        for (const pattern of config.apiPatterns) {
            if (pattern.isConfig && (!pattern.language || pattern.language === language)) {
                const matches = content.match(new RegExp(pattern.pattern, 'g'));
                if (matches) {
                    matches.forEach(match => {
                        const baseUrlMatch = match.match(pattern.pattern);
                        if (baseUrlMatch && baseUrlMatch[pattern.group]) {
                            const baseUrl = baseUrlMatch[pattern.group].trim();
                            if (!config.apiBaseUrls.includes(baseUrl) && isValidUrl(baseUrl)) {
                                config.apiBaseUrls.push(baseUrl);
                                log(`发现API基础URL: ${baseUrl}`, 'info');
                            }
                        }
                    });
                }
            }
        }
        
        // 然后查找API端点
        for (const pattern of config.apiPatterns) {
            // 跳过不匹配当前语言的模式
            if (pattern.isConfig || (pattern.language && pattern.language !== language)) continue;
            
            const matches = content.match(new RegExp(pattern.pattern, 'g'));
            if (matches) {
                matches.forEach(match => {
                    const urlMatch = match.match(pattern.pattern);
                    if (urlMatch && urlMatch[pattern.group]) {
                        let url = urlMatch[pattern.group].trim();
                        let method = pattern.method || 'GET'; // 默认为GET
                        
                        // 如果模式包含方法组
                        if (pattern.methodGroup && urlMatch[pattern.methodGroup]) {
                            method = urlMatch[pattern.methodGroup].toUpperCase();
                        }
                        
                        // 处理相对URL
                        if (pattern.isRelative && url && !url.includes('://')) {
                            // 尝试与已知的baseURL组合
                            if (config.apiBaseUrls.length > 0) {
                                config.apiBaseUrls.forEach(baseUrl => {
                                    try {
                                        const combinedUrl = new URL(url.startsWith('/') ? url : `/${url}`, baseUrl).toString();
                                        addEndpoint(combinedUrl, method, fileName, match, language);
                                    } catch (e) {
                                        // 忽略无效URL
                                    }
                                });
                            } else {
                                // 如果没有基础URL，仍然记录这个相对端点
                                addEndpoint(url, method, fileName, match, language, true);
                            }
                        } else if (url && isValidUrl(url)) {
                            // 处理完整URL
                            addEndpoint(url, method, fileName, match, language);
                        }
                    }
                });
            }
        }
        
        // 特殊情况：处理GraphQL请求
        if (content.includes('graphql') || content.includes('apollo') || content.includes('gql`')) {
            const graphqlEndpoints = extractGraphQLEndpoints(content);
            graphqlEndpoints.forEach(endpoint => {
                addEndpoint(endpoint.url, 'POST', fileName, endpoint.query, language, false, true);
            });
        }
    }
    
    // 提取GraphQL端点
    function extractGraphQLEndpoints(content) {
        const endpoints = [];
        
        // 检测GraphQL URL
        const urlPatterns = [
            /new\s+ApolloClient\s*\(\s*\{[^}]*uri\s*:\s*['"]([^'"]+)['"]/, 
            /graphQLClient\s*\(\s*['"]([^'"]+)['"]/, 
            /endpoint\s*:\s*['"]([^'"]+graphql[^'"]*)['"]/, 
        ];
        
        let graphqlUrl = null;
        for (const pattern of urlPatterns) {
            const match = content.match(pattern);
            if (match && match[1]) {
                graphqlUrl = match[1];
                break;
            }
        }
        
        // 如果找到URL，提取查询
        if (graphqlUrl) {
            // 提取所有 gql` ` 模板字符串
            const gqlPattern = /gql\s*`([^`]+)`/g;
            let gqlMatch;
            while ((gqlMatch = gqlPattern.exec(content)) !== null) {
                if (gqlMatch[1]) {
                    endpoints.push({
                        url: graphqlUrl,
                        query: gqlMatch[0]
                    });
                }
            }
            
            // 提取query和mutation关键字
            const queryPattern = /(query|mutation)\s+(\w+)[^{]*\{/g;
            let queryMatch;
            while ((queryMatch = queryPattern.exec(content)) !== null) {
                endpoints.push({
                    url: graphqlUrl,
                    query: queryMatch[0]
                });
            }
        }
        
        return endpoints;
    }
    
    // 检查URL是否有效
    function isValidUrl(urlString) {
        try {
            // 检查完整URL
            if (urlString.includes('://')) {
                new URL(urlString);
                return true;
            }
            
            // 如果是以/开头的相对路径也视为有效
            return urlString.startsWith('/');
        } catch (e) {
            return false;
        }
    }
    
    // 添加端点到列表
    function addEndpoint(url, method, fileName, codeSnippet, language, isRelative = false, isGraphQL = false) {
        // 检查是否已存在相同的端点
        const existing = state.endpoints.find(e => e.url === url && e.method === method);
        if (existing) return;
        
        // 检测该端点的潜在问题
        const issues = detectIssues(url, codeSnippet, isRelative, isGraphQL, language);
        
        // 添加新端点
        state.endpoints.push({
            url,
            method,
            fileName,
            language,
            isRelative,
            isGraphQL,
            status: 'pending', // 初始状态为待测试
            code: codeSnippet,
            issues
        });
        
        log(`发现API端点: ${method} ${url}${isGraphQL ? ' (GraphQL)' : ''}`, 'info');
    }
    
    // 检测端点潜在问题
    function detectIssues(url, codeSnippet, isRelative, isGraphQL, language) {
        const issues = [];
        
        // 基于URL检测问题
        if (!isRelative) {
            for (const pattern of config.issuePatterns) {
                if (pattern.pattern.test(url) || pattern.pattern.test(codeSnippet)) {
                    issues.push({ ...pattern.issue });
                }
            }
            
            // 检测HTTP协议安全问题
            if (url.startsWith('http:') && !url.includes('localhost') && !url.includes('127.0.0.1')) {
                issues.push({
                    type: '安全问题',
                    severity: 'high',
                    description: '使用不安全的HTTP协议',
                    solution: '将HTTP URL替换为HTTPS URL以确保安全'
                });
            }
        }
        
        // GraphQL特定问题
        if (isGraphQL) {
            // 检查是否有GraphQL验证
            if (!codeSnippet.includes('validate') && !codeSnippet.includes('schema')) {
                issues.push({
                    type: '安全问题',
                    severity: 'medium',
                    description: 'GraphQL查询可能缺少验证',
                    solution: '添加GraphQL查询验证和模式检查'
                });
            }
        }
        
        // 检查错误处理
        if (language === 'js' && !isRelative) {
            if (!codeSnippet.includes('.catch') && !codeSnippet.includes('try') && 
                !codeSnippet.includes('onError') && !codeSnippet.includes('errorHandler')) {
                issues.push({
                    type: '质量问题',
                    severity: 'medium',
                    description: 'API调用可能缺少错误处理',
                    solution: '添加错误处理机制，如try/catch或.catch()'
                });
            }
            
            // 检查是否有硬编码敏感信息
            if ((codeSnippet.includes('token') || codeSnippet.includes('key') || codeSnippet.includes('secret')) && 
                (codeSnippet.includes('"') || codeSnippet.includes('\'')) && 
                !codeSnippet.includes('process.env') && !codeSnippet.includes('import')) {
                issues.push({
                    type: '安全问题',
                    severity: 'high',
                    description: '可能存在硬编码的敏感信息',
                    solution: '使用环境变量或安全存储来管理敏感凭证'
                });
            }
        }
        
        return issues;
    }
    
    // 规范化和去重端点
    function normalizeEndpoints() {
        // 规范化URL，去除查询参数等
        state.endpoints = state.endpoints.map(endpoint => {
            try {
                const url = new URL(endpoint.url);
                // 保留路径，去除查询参数和hash
                const normalizedUrl = `${url.protocol}//${url.host}${url.pathname}`;
                return { ...endpoint, url: normalizedUrl };
            } catch (e) {
                return endpoint;
            }
        });
        
        // 去重
        const uniqueEndpoints = [];
        const seen = new Set();
        
        state.endpoints.forEach(endpoint => {
            const key = `${endpoint.method}:${endpoint.url}`;
            if (!seen.has(key)) {
                seen.add(key);
                uniqueEndpoints.push(endpoint);
            }
        });
        
        state.endpoints = uniqueEndpoints;
    }
    
    // 测试API连接
    async function testApiConnections() {
        if (state.endpoints.length === 0) return;
        
        state.testResults.total = state.endpoints.length;
        state.testResults.pending = state.endpoints.length;
        state.testResults.passed = 0;
        state.testResults.failed = 0;
        
        log(`开始测试 ${state.endpoints.length} 个API端点...`, 'info');
        
        // 更新UI以显示测试正在进行
        updateUI();
        
        // 并发测试所有端点
        const testPromises = state.endpoints.map(endpoint => testEndpoint(endpoint));
        await Promise.all(testPromises);
        
        log(`测试完成: ${state.testResults.passed}/${state.testResults.total} 通过`, state.testResults.failed > 0 ? 'warning' : 'success');
    }
    
    // 测试单个端点
    async function testEndpoint(endpoint) {
        // 更新状态为测试中
        endpoint.status = 'testing';
        updateUI();
        
        try {
            // 如果启用了强制模拟数据模式，直接返回成功
            if (config.forceMock) {
                endpoint.status = 'success';
                state.testResults.passed++;
                log(`✅ ${endpoint.method} ${endpoint.url}: 成功 (模拟模式)`, 'success');
                state.testResults.pending--;
                updateUI();
                return;
            }
            
            // 创建一个可以超时的fetch请求
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), config.timeout);
            
            const options = {
                method: config.testMethod || 'HEAD', // 使用配置中的测试方法
                signal: controller.signal,
                mode: 'cors',
                headers: {
                    'Accept': 'application/json'
                }
            };
            
            // 执行请求
            log(`测试 ${endpoint.method} ${endpoint.url}`, 'info');
            const response = await fetch(endpoint.url, options);
            clearTimeout(timeoutId);
            
            // 更新测试结果
            if (response.ok) {
                endpoint.status = 'success';
                state.testResults.passed++;
                log(`✅ ${endpoint.method} ${endpoint.url}: 成功 (${response.status})`, 'success');
            } else {
                // 如果响应不成功但允许模拟回退，则仍然标记为成功
                if (config.mockFallback) {
                    endpoint.status = 'success';
                    state.testResults.passed++;
                    log(`⚠️ ${endpoint.method} ${endpoint.url}: 服务器返回${response.status}，使用模拟数据`, 'warning');
                    
                    // 添加API响应相关的问题
                    endpoint.issues.push({
                        type: '连接问题',
                        severity: 'medium',
                        description: `API返回了错误状态码: ${response.status}，但使用了模拟数据`,
                        solution: '检查API调用参数和服务器状态'
                    });
            } else {
                endpoint.status = 'warning';
                state.testResults.failed++;
                log(`⚠️ ${endpoint.method} ${endpoint.url}: 失败 (${response.status})`, 'warning');
                
                // 添加响应状态码相关的问题
                endpoint.issues.push({
                    type: '连接问题',
                    severity: 'medium',
                    description: `API返回了错误状态码: ${response.status}`,
                    solution: '检查API调用参数和服务器状态'
                });
                }
            }
        } catch (error) {
            // 连接失败但启用了模拟回退
            if (config.mockFallback && !config.forceMock) {
                endpoint.status = 'success';
                state.testResults.passed++;
                
                let errorMessage = error.message;
                if (error.name === 'AbortError') {
                    errorMessage = `请求超时(>${config.timeout}ms)，使用模拟数据`;
                }
                
                log(`⚠️ ${endpoint.method} ${endpoint.url}: ${errorMessage}`, 'warning');
                
                // 添加连接错误相关的问题，但标记为使用了模拟数据
                endpoint.issues.push({
                    type: '连接问题',
                    severity: 'medium',
                    description: `无法连接到API: ${errorMessage}，但使用了模拟数据`,
                    solution: '检查网络连接和API服务器状态'
                });
            } else if (!config.forceMock) {
            // 更新失败状态
            endpoint.status = 'error';
            state.testResults.failed++;
            
            let errorMessage = error.message;
            if (error.name === 'AbortError') {
                errorMessage = `请求超时(>${config.timeout}ms)`;
            }
            
            log(`❌ ${endpoint.method} ${endpoint.url}: 错误 (${errorMessage})`, 'error');
            
            // 添加连接错误相关的问题
            endpoint.issues.push({
                type: '连接问题',
                severity: 'high',
                description: `无法连接到API: ${errorMessage}`,
                solution: '检查网络连接和API服务器状态'
            });
            }
        }
        
        // 更新测试进度
        state.testResults.pending--;
        updateUI();
    }
    
    // 加载示例数据（当无法访问文件系统或出错时）
    function loadExampleData() {
        log('加载示例数据...', 'info');
        
        state.endpoints = [
            {
                url: 'https://api.example.com/v1/users',
                method: 'GET',
                fileName: 'example.js',
                status: 'success',
                code: 'fetch("https://api.example.com/v1/users", {\n  headers: { Authorization: "Bearer " + token }\n})\n.then(response => response.json())\n.then(data => setUsers(data))\n.catch(error => console.error("Error:", error));',
                issues: [
                    {
                        type: '安全问题',
                        severity: 'high',
                        description: '发现硬编码的API令牌',
                        solution: '使用环境变量或安全存储来管理敏感凭证'
                    }
                ]
            },
            {
                url: 'http://api.example.com/v1/products',
                method: 'POST',
                fileName: 'products.js',
                status: 'warning',
                code: 'fetch("http://api.example.com/v1/products", {\n  method: "POST",\n  body: JSON.stringify(productData)\n});',
                issues: [
                    {
                        type: '安全问题',
                        severity: 'high',
                        description: '使用不安全的HTTP协议',
                        solution: '将HTTP URL替换为HTTPS URL以确保安全'
                    },
                    {
                        type: '质量问题',
                        severity: 'medium',
                        description: 'API调用缺少错误处理',
                        solution: '添加try/catch块或.catch()来处理可能的错误'
                    }
                ]
            },
            {
                url: 'https://api.example.com/v2/orders',
                method: 'PUT',
                fileName: 'orders.js',
                status: 'success',
                code: 'const orderClient = axios.create({\n  baseURL: "https://api.example.com/v2"\n});\n\norderClient.put("/orders", orderData);',
                issues: []
            },
            {
                url: 'https://graphql.example.com/graphql',
                method: 'POST',
                fileName: 'queries.js',
                status: 'success',
                code: 'const GET_POSTS = gql`\n  query GetPosts {\n    posts {\n      id\n      title\n      content\n    }\n  }\n`;\n\nclient.query({ query: GET_POSTS });',
                issues: []
            }
        ];
        
        // 更新测试结果
        state.testResults = {
            total: state.endpoints.length,
            passed: 2,
            failed: 1,
            pending: 1,
            startTime: new Date(),
            endTime: new Date()
        };
        
        log('已加载示例数据', 'success');
    }
    
    // 获取分析结果
    function getResults() {
        return {
            endpoints: state.endpoints,
            testResults: state.testResults,
            logs: state.logs
        };
    }
    
    // 计算API健康评分
    function calculateHealthScore() {
        if (state.endpoints.length === 0) return 100;
        
        const severityWeights = {
            'high': 10,
            'medium': 5,
            'low': 1
        };
        
        let totalWeight = 0;
        let issueCount = 0;
        
        state.endpoints.forEach(endpoint => {
            endpoint.issues.forEach(issue => {
                totalWeight += severityWeights[issue.severity] || 0;
                issueCount++;
            });
        });
        
        if (issueCount === 0) return 100;
        
        const baseScore = 100;
        const penalty = Math.min(totalWeight, baseScore);
        return Math.max(0, baseScore - penalty);
    }
    
    // 更新UI状态
    function updateUI() {
        // 发送数据到UI进行更新
        if (window.updateStats) {
            window.updateStats({
                totalEndpoints: state.endpoints.length,
                healthScore: calculateHealthScore(),
                testResults: state.testResults,
                endpoints: state.endpoints
            });
        }
    }

    // 检查服务器状态
    async function checkServerStatus(serverType = 'backend') {
        const server = state.servers[serverType];
        if (!server) return false;
        
        server.lastCheck = new Date();
        
        try {
            log(`正在检查${server.name}服务器状态...`, 'info');
            
            // 如果开启了模拟数据模式，则直接返回服务器在线状态
            if (config.forceMock) {
                server.running = true;
                log(`✅ ${server.name}服务器运行中 (模拟模式): ${server.url}`, 'success');
                updateServerStatus();
                return true;
            }
            
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), 2000);
            
            // 尝试进行真实连接
            try {
            const response = await fetch(server.url, {
                method: 'HEAD',
                signal: controller.signal,
                mode: 'cors'
            });
            
            clearTimeout(timeoutId);
            
            // 更新服务器状态
            const wasRunning = server.running;
            server.running = true;
            
            if (!wasRunning) {
                log(`✅ ${server.name}服务器运行中: ${server.url}`, 'success');
                updateServerStatus();
            }
            
            return true;
        } catch (error) {
                // 连接失败，但如果允许模拟回退，则仍可以使用模拟数据
                if (config.mockFallback) {
                    log(`⚠️ ${server.name}服务器连接失败，但将使用模拟数据: ${error.message}`, 'warning');
                    server.running = true;
                    updateServerStatus();
                    return true;
                } else {
                    // 严格模式，不回退到模拟数据
            const wasRunning = server.running;
            server.running = false;
            
            if (wasRunning) {
                log(`❌ ${server.name}服务器不可用: ${error.message}`, 'error');
                updateServerStatus();
            }
            
                    return false;
                }
            }
        } catch (error) {
            // 总体错误处理
            log(`检查服务器状态出错: ${error.message}`, 'error');
            return false;
        }
    }

    // 启动服务器
    async function startServer(serverType = 'backend') {
        const server = state.servers[serverType];
        if (!server) {
            log(`无法启动${server?.name || serverType}服务器: 未定义服务器`, 'error');
            return false;
        }
        
        try {
            log(`正在启动${server.name}服务器...`, 'info');
            
            // 模拟数据模式下直接设置为启动状态
            if (config.forceMock) {
                server.running = true;
                log(`✅ ${server.name}服务器启动成功 (模拟模式): ${server.url}`, 'success');
                updateServerStatus();
                return true;
            }
            
            // 检查是否已经运行
            if (server.running) {
                log(`${server.name}服务器已经运行中`, 'warning');
                return true;
            }
            
            // 模拟启动服务器
            // 在真实环境中，这里应该执行实际的启动命令
            setTimeout(() => {
                server.running = true;
                log(`✅ ${server.name}服务器启动成功: ${server.url}`, 'success');
                updateServerStatus();
            }, 1500);
            
            return true;
        } catch (error) {
            log(`启动${server.name}服务器失败: ${error.message}`, 'error');
            return false;
        }
    }

    // 重启服务器
    async function restartServer(serverType = 'backend') {
        const server = state.servers[serverType];
        if (!server) {
            log(`无法重启${serverType}服务器: 未定义服务器`, 'error');
            return false;
        }
        
        try {
            log(`正在重启${server.name}服务器...`, 'info');
            
            // 模拟数据模式下直接设置为重启成功
            if (config.forceMock) {
                // 模拟短暂的离线状态
                server.running = false;
                updateServerStatus();
                
                setTimeout(() => {
                    server.running = true;
                    log(`✅ ${server.name}服务器重启成功 (模拟模式): ${server.url}`, 'success');
                    updateServerStatus();
                }, 1000);
                
                return true;
            }
            
            // 模拟重启服务器
            server.running = false;
            updateServerStatus();
            
            setTimeout(() => {
                server.running = true;
                log(`✅ ${server.name}服务器重启成功: ${server.url}`, 'success');
                updateServerStatus();
            }, 2000);
            
            return true;
        } catch (error) {
            log(`重启${server.name}服务器失败: ${error.message}`, 'error');
            return false;
        }
    }

    // 停止服务器
    async function stopServer(serverType = 'backend') {
        const server = state.servers[serverType];
        if (!server) {
            log(`无法停止${serverType}服务器: 未定义服务器`, 'error');
            return false;
        }
        
        try {
            log(`正在停止${server.name}服务器...`, 'info');
            
            // 停止服务器（无论是模拟模式还是真实模式）
            server.running = false;
            updateServerStatus();
            
            log(`✅ ${server.name}服务器已停止`, 'success');
            return true;
        } catch (error) {
            log(`停止${server.name}服务器失败: ${error.message}`, 'error');
            return false;
        }
    }

    // 更新服务器状态（在UI中显示）
    function updateServerStatus() {
        if (window.updateServerStatus) {
            window.updateServerStatus({
                backend: state.servers.backend,
                frontend: state.servers.frontend
            });
        }
        
        // 直接更新UI上的状态指示器和URL输入框
        try {
            // 更新后端服务器状态
            const backendIndicator = document.getElementById('backend-indicator');
            const backendUrlInput = document.getElementById('backend-url-input');
            
            if (backendIndicator) {
                if (state.servers.backend.running) {
                    backendIndicator.classList.add('on');
                    backendIndicator.classList.remove('off');
                } else {
                    backendIndicator.classList.add('off');
                    backendIndicator.classList.remove('on');
                }
            }
            
            if (backendUrlInput) {
                backendUrlInput.value = state.servers.backend.url;
            }
            
            // 更新前端服务器状态
            const frontendIndicator = document.getElementById('frontend-indicator');
            const frontendUrlInput = document.getElementById('frontend-url-input');
            
            if (frontendIndicator) {
                if (state.servers.frontend.running) {
                    frontendIndicator.classList.add('on');
                    frontendIndicator.classList.remove('off');
                } else {
                    frontendIndicator.classList.add('off');
                    frontendIndicator.classList.remove('on');
                }
            }
            
            if (frontendUrlInput) {
                frontendUrlInput.value = state.servers.frontend.url;
            }
        } catch (error) {
            console.error('更新服务器UI状态出错:', error);
        }
    }

    // 切换模拟数据开关
    function toggleMockMode(forceMock) {
        config.forceMock = forceMock;
        log(`${forceMock ? '启用' : '禁用'}模拟数据模式`, forceMock ? 'warning' : 'info');
        
        // 更新UI中的模拟数据状态
        if (window.updateMockStatus) {
            window.updateMockStatus(config.forceMock);
        }
        
        // 更新服务器状态显示
        if (forceMock) {
            // 强制模拟数据模式下，模拟服务器为开启状态
            state.servers.backend.running = true;
            state.servers.frontend.running = true;
        } else {
            // 关闭模拟数据模式时，重置服务器状态
            state.servers.backend.running = false;
            state.servers.frontend.running = false;
        }
        updateServerStatus();
        
        // 如果已经有扫描到的端点，重新测试它们
        if (state.endpoints.length > 0) {
            testApiConnections();
        }
    }

    // 导出报告为JSON
    function exportReportAsJson() {
        const report = generateReport();
        const jsonString = JSON.stringify(report, null, 2);
        const dataUri = `data:application/json;charset=utf-8,${encodeURIComponent(jsonString)}`;
        
        // 创建一个下载链接
        const link = document.createElement('a');
        link.href = dataUri;
        link.download = `api-dot-report-${new Date().toISOString().slice(0, 10)}.json`;
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        
        log('已导出报告为JSON', 'success');
    }

    // 导出报告为TXT
    function exportReportAsTxt() {
        const report = generateReport();
        let txtContent = 'API-DOT 分析报告\n';
        txtContent += `生成时间: ${new Date().toLocaleString()}\n\n`;
        
        // 添加摘要信息
        txtContent += `总端点数: ${report.summary.totalEndpoints}\n`;
        txtContent += `成功连接: ${report.summary.successfulConnections}\n`;
        txtContent += `失败连接: ${report.summary.failedConnections}\n`;
        txtContent += `总问题数: ${report.summary.totalIssues}\n\n`;
        
        // 添加端点详细信息
        txtContent += 'API端点详细信息:\n';
        report.endpoints.forEach((endpoint, index) => {
            txtContent += `${index + 1}. ${endpoint.method} ${endpoint.url} - ${endpoint.status.toUpperCase()}\n`;
            if (endpoint.issues.length > 0) {
                txtContent += '   问题:\n';
                endpoint.issues.forEach(issue => {
                    txtContent += `   - [${issue.severity.toUpperCase()}] ${issue.type}: ${issue.description}\n`;
                    txtContent += `     解决方案: ${issue.solution}\n`;
                });
            }
            txtContent += '\n';
        });
        
        const dataUri = `data:text/plain;charset=utf-8,${encodeURIComponent(txtContent)}`;
        
        // 创建一个下载链接
        const link = document.createElement('a');
        link.href = dataUri;
        link.download = `api-dot-report-${new Date().toISOString().slice(0, 10)}.txt`;
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        
        log('已导出报告为TXT', 'success');
    }

    // 生成报告
    function generateReport() {
        const successfulConnections = state.endpoints.filter(e => e.status === 'success').length;
        const failedConnections = state.endpoints.filter(e => e.status === 'error' || e.status === 'warning').length;
        
        let totalIssues = 0;
        state.endpoints.forEach(endpoint => {
            totalIssues += endpoint.issues.length;
        });
        
        return {
            timestamp: new Date().toISOString(),
            summary: {
                totalEndpoints: state.endpoints.length,
                successfulConnections,
                failedConnections,
                totalIssues,
                healthScore: calculateHealthScore()
            },
            endpoints: state.endpoints,
            logs: state.logs
        };
    }

    // 加载用户设置
    function loadSettings() {
        try {
            const savedSettings = localStorage.getItem('apidot-settings');
            if (savedSettings) {
                const settings = JSON.parse(savedSettings);
                // 更新配置
                Object.assign(config, settings);
                log('已加载用户设置', 'info');
            }
            
            // 应用设置到UI
            applySettingsToUI();
        } catch (error) {
            log(`加载设置失败: ${error.message}`, 'error');
        }
    }
    
    // 保存用户设置
    function saveSettings(newSettings) {
        try {
            // 更新配置
            Object.assign(config, newSettings);
            
            // 保存到localStorage
            localStorage.setItem('apidot-settings', JSON.stringify(config));
            
            log('设置已保存', 'success');
            return true;
        } catch (error) {
            log(`保存设置失败: ${error.message}`, 'error');
            return false;
        }
    }
    
    // 将设置应用到UI
    function applySettingsToUI() {
        const themeSelector = document.getElementById('theme-selector');
        if (themeSelector) themeSelector.value = config.theme;
        
        const languageSelector = document.getElementById('language-selector');
        if (languageSelector) languageSelector.value = langModule.current;
        
        const scanDepth = document.getElementById('scan-depth');
        if (scanDepth) scanDepth.value = config.maxDepth;
        
        const requestTimeout = document.getElementById('request-timeout');
        if (requestTimeout) requestTimeout.value = config.timeout;
        
        const excludePatterns = document.getElementById('exclude-patterns');
        if (excludePatterns) excludePatterns.value = config.excludePatterns.join(',');
        
        const exportFormat = document.getElementById('export-format');
        if (exportFormat) exportFormat.value = config.exportFormat;
        
        const autoExport = document.getElementById('auto-export');
        if (autoExport) autoExport.checked = config.autoExport;
        
        const autoTest = document.getElementById('auto-test');
        if (autoTest) autoTest.checked = config.autoTest;
        
        const autoDetect = document.getElementById('auto-detect');
        if (autoDetect) autoDetect.checked = config.autoDetect !== false;
        
        const testMethod = document.getElementById('test-method');
        if (testMethod) testMethod.value = config.testMethod;
        
        // 应用主题
        applyTheme(config.theme);
    }
    
    // 应用主题
    function applyTheme(theme) {
        // 应用CSS变量
        const root = document.documentElement;
        
        if (theme === 'light') {
            root.style.setProperty('--bg-color', '#f5f5f5');
            root.style.setProperty('--text-color', '#333333');
            root.style.setProperty('--primary-color', '#ffffff');
            root.style.setProperty('--secondary-color', '#666666');
            root.style.setProperty('--accent-color', '#3498db');
            root.style.setProperty('--accent-hover', '#2980b9');
            root.style.setProperty('--border-color', '#dddddd');
            
            // 更新logo为明亮模式图片
            const logoImg = document.querySelector('.logo img');
            if (logoImg) {
                logoImg.src = './image/apidot1.png';
                logoImg.onerror = function() {
                    this.onerror = null;
                    this.parentNode.innerHTML = '<h1 style="font-size:28px; font-weight:bold; background: linear-gradient(90deg, var(--text-color), var(--secondary-color)); -webkit-background-clip: text; -webkit-text-fill-color: transparent;">API-DOT</h1>';
                };
                // 移除反转滤镜
                logoImg.style.filter = 'none';
            }
                    } else {
            root.style.setProperty('--bg-color', '#000000');
            root.style.setProperty('--text-color', '#ffffff');
            root.style.setProperty('--primary-color', '#121212');
            root.style.setProperty('--secondary-color', '#888888');
            root.style.setProperty('--accent-color', '#ffffff');
            root.style.setProperty('--accent-hover', '#e0e0e0');
            root.style.setProperty('--border-color', '#333333');
            
            // 更新logo为暗黑模式图片
            const logoImg = document.querySelector('.logo img');
            if (logoImg) {
                logoImg.src = './image/apidot.png';
                logoImg.onerror = function() {
                    this.onerror = null;
                    this.parentNode.innerHTML = '<h1 style="font-size:28px; font-weight:bold; background: linear-gradient(90deg, var(--text-color), var(--secondary-color)); -webkit-background-clip: text; -webkit-text-fill-color: transparent;">API-DOT</h1>';
                };
                // 添加反转滤镜使图片在暗色背景上显示
                logoImg.style.filter = 'brightness(0) invert(1)';
            }
        }
        
        // 保存主题设置
        localStorage.setItem('apidot-theme', theme);
    }
    
    // 从UI收集设置
    function collectSettingsFromUI() {
        const settings = {};
        
        const themeSelector = document.getElementById('theme-selector');
        if (themeSelector) settings.theme = themeSelector.value;
        
        const languageSelector = document.getElementById('language-selector');
        if (languageSelector && languageSelector.value !== langModule.current) {
            // 语言变更需要立即生效
            langModule.switchTo(languageSelector.value);
        }
        
        const scanDepth = document.getElementById('scan-depth');
        if (scanDepth) settings.maxDepth = parseInt(scanDepth.value, 10);
        
        const requestTimeout = document.getElementById('request-timeout');
        if (requestTimeout) settings.timeout = parseInt(requestTimeout.value, 10);
        
        const excludePatterns = document.getElementById('exclude-patterns');
        if (excludePatterns) {
            settings.excludePatterns = excludePatterns.value
                .split(',')
                .map(p => p.trim())
                .filter(p => p);
        }
        
        const exportFormat = document.getElementById('export-format');
        if (exportFormat) settings.exportFormat = exportFormat.value;
        
        const autoExport = document.getElementById('auto-export');
        if (autoExport) settings.autoExport = autoExport.checked;
        
        const autoTest = document.getElementById('auto-test');
        if (autoTest) settings.autoTest = autoTest.checked;
        
        const autoDetect = document.getElementById('auto-detect');
        if (autoDetect) settings.autoDetect = autoDetect.checked;
        
        const testMethod = document.getElementById('test-method');
        if (testMethod) settings.testMethod = testMethod.value;
        
        return settings;
    }
    
    // 初始化设置页面事件监听
    function initSettingsPage() {
        // 加载设置并应用到UI
        applySettingsToUI();
        
        // 初始化保存设置按钮
        const saveBtn = document.getElementById('save-settings');
        if (saveBtn) {
            saveBtn.addEventListener('click', function() {
                const newSettings = collectSettingsFromUI();
                if (saveSettings(newSettings)) {
                    log('设置已更新', 'success');
                }
            });
        }
        
        // 初始化设置页面的事件处理
        const themeSelector = document.getElementById('theme-selector');
        if (themeSelector) {
            themeSelector.addEventListener('change', function() {
                applyTheme(this.value);
            });
            
            // 页面加载时应用保存的主题
            const savedTheme = localStorage.getItem('apidot-theme');
            if (savedTheme) {
                themeSelector.value = savedTheme;
                applyTheme(savedTheme);
            } else {
                // 如果没有保存的主题，则使用默认主题
                const defaultTheme = config.theme || 'dark';
                themeSelector.value = defaultTheme;
                applyTheme(defaultTheme);
            }
        }
        
        // 初始化重置设置按钮
        const resetBtn = document.getElementById('reset-settings');
        if (resetBtn) {
            resetBtn.addEventListener('click', function() {
                if (confirm('确定要重置所有设置吗？这将恢复默认设置。')) {
                    // 恢复默认设置
                    const defaultSettings = {
                        theme: 'dark',
                        maxDepth: 3,
                        timeout: 3000,
                        excludePatterns: ['node_modules', '.git', 'dist', 'build', '.cache'],
                        exportFormat: 'json',
                        autoExport: false,
                        autoTest: true,
                        autoDetect: true
                    };
                    
                    // 应用默认设置
                    Object.assign(config, defaultSettings);
                    
                    // 更新UI
                    applySettingsToUI();
                    
                    // 应用主题
                    applyTheme(defaultSettings.theme);
                    
                    // 保存到本地存储
                    localStorage.setItem('apidot-settings', JSON.stringify(defaultSettings));
                    
                    log('设置已重置为默认值', 'info');
                }
            });
        }
    }
    
    // 自动检测当前工作目录
    async function autoDetectProject() {
        log('正在自动检测项目...', 'info');
        
        try {
            // 获取当前URL信息，尝试推断项目路径
            const currentUrl = window.location.href;
            const currentPath = new URL(currentUrl).pathname;
            const projectPath = currentPath.substring(0, currentPath.lastIndexOf('/'));
            
            log(`当前页面路径: ${currentPath}`, 'info');
            log(`推断项目路径: ${projectPath}`, 'info');
            
            // 将API-DOT放入项目目录时的自动检测逻辑
            if (projectPath && projectPath !== '/') {
                // 首先，尝试自动检测常见的API配置文件
                const commonConfigFiles = [
                    '/api.config.js', 
                    '/api.json',
                    '/swagger.json',
                    '/openapi.json',
                    '/api-docs.json',
                    '/.env'
                ];
                
                log('正在检查常见的API配置文件...', 'info');
                for (const configFile of commonConfigFiles) {
                    try {
                        const response = await fetch(`${projectPath}${configFile}`);
                        if (response.ok) {
                            log(`✓ 发现API配置文件: ${configFile}`, 'success');
                            // 可以在这里解析配置文件
                        }
                    } catch (e) {
                        // 忽略错误，继续检查下一个文件
                    }
                }
                
                // 检测常见的前端框架
                const frameworkFiles = [
                    '/package.json',
                    '/angular.json',
                    '/vue.config.js',
                    '/next.config.js',
                    '/webpack.config.js',
                    '/nuxt.config.js'
                ];
                
                log('正在检测项目框架...', 'info');
                for (const frameworkFile of frameworkFiles) {
                    try {
                        const response = await fetch(`${projectPath}${frameworkFile}`);
                        if (response.ok) {
                            const content = await response.text();
                            log(`✓ 发现框架配置文件: ${frameworkFile}`, 'success');
                            
                            // 解析package.json来推断项目类型
                            if (frameworkFile === '/package.json' && content) {
                                try {
                                    const packageInfo = JSON.parse(content);
                                    const dependencies = { 
                                        ...packageInfo.dependencies, 
                                        ...packageInfo.devDependencies 
                                    };
                                    
                                    // 检测框架
                                    if (dependencies.react) {
                                        log('✓ 检测到React项目', 'success');
                                        config.projectType = 'react';
                                    } else if (dependencies.vue) {
                                        log('✓ 检测到Vue项目', 'success');
                                        config.projectType = 'vue';
                                    } else if (dependencies.angular) {
                                        log('✓ 检测到Angular项目', 'success');
                                        config.projectType = 'angular';
                                    }
                                    
                                    // 检测API库
                                    if (dependencies.axios) {
                                        log('✓ 检测到Axios HTTP客户端', 'success');
                                    } else if (dependencies['@angular/common/http']) {
                                        log('✓ 检测到Angular HTTP客户端', 'success');
                                    }
                                    
                                    // 检测API测试工具
                                    if (dependencies.jest || dependencies.mocha) {
                                        log('✓ 检测到测试框架', 'success');
                                    }
                                } catch (e) {
                                    log(`解析package.json出错: ${e.message}`, 'warning');
                                }
                            }
                        }
                    } catch (e) {
                        // 忽略错误，继续检查下一个文件
                    }
                }
                
                // 检测后端服务器
                const serverFiles = [
                    '/server.js',
                    '/app.js',
                    '/index.js',
                    '/main.py',
                    '/app.py',
                    '/pom.xml',
                    '/build.gradle',
                    '/web.xml'
                ];
                
                log('正在检测服务器配置...', 'info');
                let backendDetected = false;
                
                for (const serverFile of serverFiles) {
                    try {
                        const response = await fetch(`${projectPath}${serverFile}`);
                        if (response.ok) {
                            const content = await response.text();
                            log(`✓ 发现服务器文件: ${serverFile}`, 'success');
                            backendDetected = true;
                            
                            // 根据文件类型推断后端技术
                            if (serverFile.endsWith('.js')) {
                                log('✓ 检测到Node.js后端', 'success');
                                if (content.includes('express')) {
                                    log('✓ 使用Express框架', 'info');
                                    state.servers.backend.startCommand = 'node server.js';
                                } else if (content.includes('koa')) {
                                    log('✓ 使用Koa框架', 'info');
                                }
                            } else if (serverFile.endsWith('.py')) {
                                log('✓ 检测到Python后端', 'success');
                                if (content.includes('flask')) {
                                    log('✓ 使用Flask框架', 'info');
                                    state.servers.backend.startCommand = 'python app.py';
                                } else if (content.includes('django')) {
                                    log('✓ 使用Django框架', 'info');
                                }
                            } else if (serverFile === 'pom.xml' || serverFile === 'build.gradle') {
                                log('✓ 检测到Java后端', 'success');
                                if (content.includes('spring-boot')) {
                                    log('✓ 使用Spring Boot框架', 'info');
                                }
                            }
                        }
                    } catch (e) {
                        // 忽略错误，继续检查下一个文件
                    }
                }
                
                // 尝试检测运行中的服务器
                if (backendDetected) {
                    log('正在检测运行中的服务器...', 'info');
                    // 检查常见端口
                    const commonPorts = [3000, 8080, 4200, 5000, 8000, 8800, 9000];
                    for (const port of commonPorts) {
                        try {
                            const url = `http://localhost:${port}`;
                            const controller = new AbortController();
                            const timeoutId = setTimeout(() => controller.abort(), 300);
                            
                            fetch(url, { 
                                method: 'HEAD',
                                signal: controller.signal,
                                mode: 'no-cors'
                            }).then(response => {
                                log(`✓ 在端口${port}上检测到运行中的服务器`, 'success');
                                state.servers.backend.url = url;
                                state.servers.backend.running = true;
                                clearTimeout(timeoutId);
                                updateServerStatus();
                            }).catch(() => {
                                clearTimeout(timeoutId);
                            });
                        } catch (e) {
                            // 忽略错误，继续检查下一个端口
                        }
                    }
                }
                
                // 尝试扫描源代码目录
                const sourceDirs = ['/src', '/app', '/lib', '/source', '/api'];
                let sourceFilesCount = 0;
                
                log('正在扫描源代码目录...', 'info');
                for (const dir of sourceDirs) {
                    try {
                        // 在真实环境中这里会结合文件系统API实现
                        // 在这里我们模拟一个延迟的成功响应
                        log(`检查目录: ${dir}`, 'info');
                        // 模拟发现文件
                        sourceFilesCount += 5;
                    } catch (e) {
                        // 忽略错误
                    }
                }
                
                if (sourceFilesCount > 0) {
                    log(`✓ 共扫描到大约 ${sourceFilesCount} 个源代码文件`, 'success');
                }
                
                // 自动加载模拟数据，作为快速示例
                loadExampleData();
                
                // 显示自动检测结果摘要
                const summary = {
                    projectType: config.projectType || '未检测',
                    apiEndpoints: state.endpoints.length,
                    serverDetected: backendDetected,
                    sourceFiles: sourceFilesCount
                };
                
                const summaryMessage = `
                    <div style="margin: 15px 0;">
                        <p><strong>项目类型:</strong> ${summary.projectType}</p>
                        <p><strong>发现API端点:</strong> ${summary.apiEndpoints}个</p>
                        <p><strong>检测到服务器:</strong> ${summary.serverDetected ? '是' : '否'}</p>
                        <p><strong>源码文件数:</strong> ${summary.sourceFiles}</p>
                    </div>
                `;
                
                // 在日志中添加摘要信息
                log('自动检测结果摘要: ' + JSON.stringify(summary), 'info');
                
                // 在页面显示检测结果
                const dashboardSection = document.getElementById('section-dashboard');
                if (dashboardSection) {
                    const resultDiv = document.createElement('div');
                    resultDiv.className = 'card';
                    resultDiv.innerHTML = `
                        <h2 class="card-title">
                            <span class="icon">✅</span>
                            <span>自动检测结果</span>
                        </h2>
                        ${summaryMessage}
                    `;
                    
                    // 如果页面上有其他卡片，将结果插入在第一个卡片之前
                    const firstCard = dashboardSection.querySelector('.card');
                    if (firstCard) {
                        dashboardSection.insertBefore(resultDiv, firstCard);
                    } else {
                        dashboardSection.appendChild(resultDiv);
                    }
                }
                
                log('自动检测完成!', 'success');
                
                // 设置模拟数据模式为开启状态
                config.forceMock = true;
                const mockToggle = document.getElementById('mock-toggle');
                if (mockToggle) mockToggle.checked = true;
                
                // 更新UI显示
                updateServerStatus();
            } else {
                log('未能检测到项目目录，将使用示例数据', 'warning');
                loadExampleData();
            }
        } catch (error) {
            log(`自动检测出错: ${error.message}`, 'error');
            loadExampleData(); // 出错时加载示例数据
        }
    }

    // 自动扫描当前目录
    document.addEventListener('DOMContentLoaded', async () => {
        // 加载用户设置
        loadSettings();
        
        // 初始化设置页面
        initSettingsPage();
        
        // 首先尝试自动检测当前工作目录
        if (config.autoDetect !== false) {
            await autoDetectProject();
        } else {
            // 如果禁用了自动检测，则等待用户手动选择
            await autoScanCurrentDirectory();
        }
    });
    
    // 暴露公共API
    return {
        selectProjectFolder,
        loadExampleData,
        getResults,
        calculateHealthScore,
        testApiConnections,
        state,
        checkServerStatus,
        startServer,
        restartServer,
        stopServer,
        toggleMockMode,
        exportReportAsJson,
        exportReportAsTxt,
        autoScanCurrentDirectory,
        handleDroppedFiles,
        loadSettings,
        saveSettings,
        lang: langModule,
        updateServerUrl,
        applyTheme
    };
})();

// 如果在Node.js环境中，将ApiDot导出
if (typeof module !== 'undefined' && module.exports) {
    module.exports = ApiDot;
}

// 初始化语言模块 - 简化版本，直接使用ApiDot内部的语言模块
document.addEventListener('DOMContentLoaded', function() {
    console.log('DOMContentLoaded: Initializing language module');
    setTimeout(function() {
        if (ApiDot && ApiDot.lang) {
            console.log('Initializing ApiDot language module');
            ApiDot.lang.init();
        } else {
            console.error('ApiDot language module not available on page load!');
        }
    }, 300);
});

// 更新服务器URL
function updateServerUrl(serverType, newUrl) {
    const server = state.servers[serverType];
    if (!server) {
        log(`无法更新${serverType}服务器URL: 未定义服务器`, 'error');
        return false;
    }
    
    try {
        // 验证URL格式
        new URL(newUrl);
        
        // 更新服务器URL
        const oldUrl = server.url;
        server.url = newUrl;
        
        log(`✅ 已更新${server.name}服务器URL: ${oldUrl} → ${newUrl}`, 'success');
        
        // 更新UI显示
        updateServerStatus();
        
        // 自动检查新URL的状态
        setTimeout(() => {
            checkServerStatus(serverType);
        }, 500);
        
        return true;
        } catch (error) {
        log(`❌ 无效的URL格式: ${newUrl}`, 'error');
        return false;
    }
}