@lmcc-dev/mult-fetch-mcp-server 1.1.0 → 1.2.1

package/dist/src/lib/fetchers/browser/PageOperations.js

@@ -0,0 +1,168 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { log, COMPONENTS } from '../../logger.js';
+import { getDomain } from '../common/utils.js';
+/**
+ * Cookie存储类 (Cookie storage class)
+ * 管理不同域名的Cookie (Manage cookies for different domains)
+ */
+export class CookieManager {
+    /**
+     * Cookie存储 (Cookie storage)
+     * 存储不同域名的Cookie (Store cookies for different domains)
+     */
+    static cookieStore = {};
+    /**
+     * 保存Cookie到存储 (Save cookies to storage)
+     * @param url 网址 (URL)
+     * @param cookies Cookie字符串 (Cookie string)
+     */
+    static saveCookies(url, cookies) {
+        const domain = getDomain(url);
+        if (domain) {
+            this.cookieStore[domain] = cookies;
+        }
+    }
+    /**
+     * 从存储获取Cookie (Get cookies from storage)
+     * @param url 网址 (URL)
+     * @returns Cookie字符串或undefined (Cookie string or undefined)
+     */
+    static getCookies(url) {
+        const domain = getDomain(url);
+        return domain ? this.cookieStore[domain] : undefined;
+    }
+}
+/**
+ * 页面操作类 (Page operations class)
+ * 提供浏览器页面的各种操作方法 (Provides various operation methods for browser pages)
+ */
+export class PageOperations {
+    /**
+     * 自动滚动页面到底部 (Auto scroll page to bottom)
+     * @param page 页面对象 (Page object)
+     * @param debug 是否启用调试输出 (Whether to enable debug output)
+     */
+    static async autoScroll(page, debug) {
+        log('browser.scrolling', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+        try {
+            await page.evaluate(async () => {
+                await new Promise((resolve) => {
+                    let totalHeight = 0;
+                    const distance = 100;
+                    const timer = setInterval(() => {
+                        const scrollHeight = document.body.scrollHeight;
+                        window.scrollBy(0, distance);
+                        totalHeight += distance;
+                        if (totalHeight >= scrollHeight) {
+                            clearInterval(timer);
+                            resolve();
+                        }
+                    }, 100);
+                });
+            });
+            log('browser.scrollCompleted', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+        }
+        catch (error) {
+            // 忽略滚动错误，不影响主要功能
+            log('browser.scrollError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+        }
+    }
+    /**
+     * 检查是否存在Cloudflare保护并尝试绕过 (Check if Cloudflare protection exists and try to bypass)
+     * @param page 页面对象 (Page object)
+     * @param url 网址 (URL)
+     * @param debug 是否启用调试输出 (Whether to enable debug output)
+     * @returns 是否成功绕过 (Whether successfully bypassed)
+     */
+    static async handleCloudflareProtection(page, url, debug) {
+        log('browser.checkingCloudflare', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+        try {
+            // 检查是否存在Cloudflare挑战页面的特征
+            const isCloudflarePage = await page.evaluate(() => {
+                return document.title.includes('Cloudflare') ||
+                    document.title.includes('Security Check') ||
+                    document.body.textContent?.includes('Checking your browser') ||
+                    document.body.textContent?.includes('Please wait') ||
+                    document.querySelector('#challenge-form') !== null;
+            });
+            if (isCloudflarePage) {
+                log('browser.cloudflareDetected', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+                // 模拟人类行为以通过Cloudflare检查
+                log('browser.simulatingHuman', debug, {}, COMPONENTS.BROWSER_FETCH);
+                await this.simulateHumanBehavior(page, debug);
+                // 等待页面加载完成
+                await page.waitForNavigation({
+                    waitUntil: 'networkidle2',
+                    timeout: 30000
+                }).catch(() => { });
+                // 再次检查是否仍在Cloudflare页面
+                const stillOnCloudflare = await page.evaluate(() => {
+                    return document.title.includes('Cloudflare') ||
+                        document.title.includes('Security Check') ||
+                        document.body.textContent?.includes('Checking your browser') ||
+                        document.querySelector('#challenge-form') !== null;
+                });
+                if (stillOnCloudflare) {
+                    log('browser.stillOnCloudflare', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+                    // 再次尝试模拟人类行为
+                    log('browser.simulatingHuman', debug, {}, COMPONENTS.BROWSER_FETCH);
+                    await this.simulateHumanBehavior(page, debug);
+                    // 再次等待页面加载
+                    await page.waitForNavigation({
+                        waitUntil: 'networkidle2',
+                        timeout: 30000
+                    }).catch(() => { });
+                    // 最终检查
+                    const bypassFailed = await page.evaluate(() => {
+                        return document.title.includes('Cloudflare') ||
+                            document.title.includes('Security Check') ||
+                            document.body.textContent?.includes('Checking your browser') ||
+                            document.querySelector('#challenge-form') !== null;
+                    });
+                    if (bypassFailed) {
+                        log('browser.bypassFailed', debug, { debug }, COMPONENTS.BROWSER_FETCH);
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            log('browser.cloudflareError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+            return false;
+        }
+    }
+    /**
+     * 模拟人类行为以绕过Cloudflare保护 (Simulate human behavior to bypass Cloudflare protection)
+     * @param page 页面对象 (Page object)
+     * @param debug 是否启用调试输出 (Whether to enable debug output)
+     */
+    static async simulateHumanBehavior(page, debug) {
+        log('browser.simulatingHuman', debug, {}, COMPONENTS.BROWSER_FETCH);
+        try {
+            // 随机移动鼠标
+            for (let i = 0; i < 5; i++) {
+                const x = Math.floor(Math.random() * 500);
+                const y = Math.floor(Math.random() * 500);
+                await page.mouse.move(x, y);
+                await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
+            }
+            // 随机点击页面
+            await page.mouse.click(Math.floor(Math.random() * 500), Math.floor(Math.random() * 500));
+            // 随机滚动
+            await page.evaluate(() => {
+                window.scrollBy(0, Math.floor(Math.random() * 200));
+            });
+            // 等待一段时间
+            await new Promise(resolve => setTimeout(resolve, 2000 + Math.random() * 2000));
+        }
+        catch (error) {
+            log('browser.simulatingHumanError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+        }
+    }
+}

package/dist/src/lib/fetchers/common/types.js

@@ -0,0 +1,41 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { z } from "zod";
+/**
+ * 浏览器特定参数 (Browser-specific parameters)
+ */
+export const BrowserParamsSchema = z.object({
+    waitForSelector: z.string().optional(),
+    waitForTimeout: z.number().optional(),
+    scrollToBottom: z.boolean().optional(),
+    saveCookies: z.boolean().optional(),
+    useBrowser: z.boolean().optional(),
+    useNodeFetch: z.boolean().optional(),
+    autoDetectMode: z.boolean().optional(),
+    closeBrowser: z.boolean().optional(),
+});
+/**
+ * 请求参数模式 (Request parameters schema)
+ */
+export const RequestPayloadSchema = z.object({
+    url: z.string(),
+    method: z.string().optional(),
+    headers: z.record(z.string()).optional(),
+    proxy: z.string().optional(),
+    noDelay: z.boolean().optional(),
+    timeout: z.number().optional(),
+    maxRedirects: z.number().optional(),
+    useSystemProxy: z.boolean().optional(),
+    debug: z.boolean().optional(),
+    useBrowser: z.boolean().optional(),
+    useNodeFetch: z.boolean().optional(),
+    autoDetectMode: z.boolean().optional(),
+    waitForSelector: z.string().optional(),
+    waitForTimeout: z.number().optional(),
+    scrollToBottom: z.boolean().optional(),
+    closeBrowser: z.boolean().optional(),
+    saveCookies: z.boolean().optional(),
+}).merge(BrowserParamsSchema);

package/dist/src/lib/fetchers/common/utils.js

@@ -0,0 +1,141 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { execSync } from 'child_process';
+import { log, COMPONENTS } from '../../logger.js';
+import { t } from '../../i18n/index.js';
+/**
+ * 常用浏览器的User-Agent列表 (List of common browser User-Agents)
+ * 用于模拟不同浏览器的请求 (Used to simulate requests from different browsers)
+ */
+export const userAgents = [
+    // Chrome
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    // Firefox
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0',
+    // Safari
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
+    // Edge
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59'
+];
+/**
+ * 获取随机User-Agent (Get random User-Agent)
+ * @returns 随机的User-Agent字符串 (Random User-Agent string)
+ */
+export function getRandomUserAgent() {
+    const index = Math.floor(Math.random() * userAgents.length);
+    return userAgents[index];
+}
+/**
+ * 随机延迟函数 (Random delay function)
+ * 模拟人类行为，避免被检测为机器人 (Simulate human behavior, avoid being detected as a bot)
+ * @param minMs 最小延迟毫秒数 (Minimum delay in milliseconds)
+ * @param maxMs 最大延迟毫秒数 (Maximum delay in milliseconds)
+ * @returns Promise对象 (Promise object)
+ */
+export async function randomDelay(minMs = 500, maxMs = 3000) {
+    const delay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+/**
+ * 从URL中提取域名 (Extract domain from URL)
+ * @param url URL字符串 (URL string)
+ * @returns 域名字符串 (Domain string)
+ */
+export function getDomain(url) {
+    try {
+        const urlObj = new URL(url);
+        return urlObj.hostname;
+    }
+    catch (error) {
+        return '';
+    }
+}
+/**
+ * 获取系统代理设置 (Get system proxy settings)
+ * @param useSystemProxy 是否使用系统代理 (Whether to use system proxy)
+ * @param debug 是否启用调试输出 (Whether to enable debug output)
+ * @param component 组件名称 (Component name)
+ * @returns 系统代理URL或undefined (System proxy URL or undefined)
+ */
+export function getSystemProxy(useSystemProxy = true, debug = false, component = COMPONENTS.NODE_FETCH) {
+    // 如果不使用系统代理，直接返回undefined (If not using system proxy, return undefined directly)
+    if (!useSystemProxy) {
+        log('fetcher.systemProxyDisabled', debug, {}, component);
+        return undefined;
+    }
+    // 检查所有可能的代理环境变量 (Check all possible proxy environment variables)
+    const proxyVars = [
+        'HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy',
+        'ALL_PROXY', 'all_proxy', 'NO_PROXY', 'no_proxy'
+    ];
+    // 输出所有环境变量的值，帮助调试 (Output all environment variable values to help debugging)
+    log('fetcher.checkingProxyEnv', debug, {}, component);
+    for (const varName of proxyVars) {
+        log('fetcher.envVarValue', debug, {
+            envVar: varName,
+            value: process.env[varName] || t('fetcher.notSet')
+        }, component);
+    }
+    // 尝试获取代理设置 (Try to get proxy settings)
+    const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY ||
+        process.env.http_proxy || process.env.https_proxy ||
+        process.env.ALL_PROXY || process.env.all_proxy;
+    if (proxyUrl) {
+        log('fetcher.foundSystemProxy', debug, { proxy: proxyUrl }, component);
+        return proxyUrl;
+    }
+    // 尝试从系统命令获取代理设置
+    try {
+        let shellOutput = '';
+        if (process.platform === 'win32') {
+            // Windows 系统使用 set 命令，忽略错误 (Windows systems use set command, ignore errors)
+            try {
+                shellOutput = execSync('set http_proxy & set https_proxy & set HTTP_PROXY & set HTTPS_PROXY', { encoding: 'utf8' });
+            }
+            catch (winError) {
+                log('fetcher.errorGettingWindowsEnvVars', debug, { error: winError.toString() }, component);
+            }
+        }
+        else {
+            // Unix 系统使用 env 命令，忽略错误 (Unix systems use env command, ignore errors)
+            try {
+                // 使用 env 命令获取所有环境变量，不使用 grep 过滤，避免在没有匹配时返回非零退出码
+                shellOutput = execSync('env', { encoding: 'utf8' });
+                // 在代码中过滤代理相关的环境变量
+                shellOutput = shellOutput.split('\n')
+                    .filter(line => line.toLowerCase().includes('proxy'))
+                    .join('\n');
+            }
+            catch (unixError) {
+                log('fetcher.errorGettingUnixEnvVars', debug, { error: unixError.toString() }, component);
+            }
+        }
+        if (shellOutput.trim()) {
+            log('fetcher.systemCommandProxySettings', debug, { output: shellOutput.trim() }, component);
+            // 解析输出找到代理 URL
+            const proxyMatch = shellOutput.match(/(?:HTTP_PROXY|HTTPS_PROXY|http_proxy|https_proxy)=([^\s]+)/i);
+            if (proxyMatch && proxyMatch[1]) {
+                const systemProxyUrl = proxyMatch[1];
+                log('fetcher.foundProxyFromCommand', debug, { proxy: systemProxyUrl }, component);
+                return systemProxyUrl;
+            }
+        }
+        else {
+            log('fetcher.noSystemProxyFound', debug, {}, component);
+        }
+    }
+    catch (error) {
+        log('fetcher.errorGettingSystemEnvVars', debug, { error: error.toString() }, component);
+    }
+    // 检查是否设置了 NO_PROXY
+    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+    if (noProxy) {
+        log('fetcher.foundNoProxy', debug, { noProxy: noProxy }, component);
+    }
+    return undefined;
+}

package/dist/src/lib/fetchers/index.js

@@ -0,0 +1,62 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { FetcherFactory } from './FetcherFactory.js';
+import { log, COMPONENTS } from '../logger.js';
+/**
+ * 统一抓取器类 (Unified fetcher class)
+ * 提供统一的接口来获取不同格式的内容 (Provides a unified interface to fetch content in different formats)
+ */
+export class Fetcher {
+    /**
+     * 获取HTML内容 (Get HTML content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns HTML内容 (HTML content)
+     */
+    static async html(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.fetchingHtml', debug, { url: requestPayload.url }, COMPONENTS.SERVER);
+        const fetcher = FetcherFactory.createFetcher(requestPayload);
+        return await fetcher.html(requestPayload);
+    }
+    /**
+     * 获取JSON内容 (Get JSON content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns JSON内容 (JSON content)
+     */
+    static async json(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.fetchingJson', debug, { url: requestPayload.url }, COMPONENTS.SERVER);
+        const fetcher = FetcherFactory.createFetcher(requestPayload);
+        return await fetcher.json(requestPayload);
+    }
+    /**
+     * 获取纯文本内容 (Get plain text content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns 纯文本内容 (Plain text content)
+     */
+    static async txt(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.fetchingTxt', debug, { url: requestPayload.url }, COMPONENTS.SERVER);
+        const fetcher = FetcherFactory.createFetcher(requestPayload);
+        return await fetcher.txt(requestPayload);
+    }
+    /**
+     * 获取Markdown内容 (Get Markdown content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns Markdown内容 (Markdown content)
+     */
+    static async markdown(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.fetchingMarkdown', debug, { url: requestPayload.url }, COMPONENTS.SERVER);
+        const fetcher = FetcherFactory.createFetcher(requestPayload);
+        return await fetcher.markdown(requestPayload);
+    }
+}
+// 导出所有类型和类 (Export all types and classes)
+export * from './common/types.js';
+export * from './browser/BrowserFetcher.js';
+export * from './node/NodeFetcher.js';
+export * from './FetcherFactory.js';

package/dist/src/lib/fetchers/node/HttpClient.js

@@ -0,0 +1,239 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import fetch from "node-fetch";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { log, COMPONENTS } from '../../logger.js';
+import { getRandomUserAgent, randomDelay, getSystemProxy } from '../common/utils.js';
+/**
+ * HTTP客户端类 (HTTP client class)
+ * 处理HTTP请求、重定向和错误 (Handle HTTP requests, redirects and errors)
+ */
+export class HttpClient {
+    /**
+     * 准备请求头 (Prepare request headers)
+     * @param headers 原始请求头 (Original headers)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @returns 处理后的请求头 (Processed headers)
+     */
+    static prepareHeaders(headers = {}, debug) {
+        const requestHeaders = { ...headers };
+        // 添加随机User-Agent (Add random User-Agent)
+        if (!requestHeaders['User-Agent']) {
+            const userAgent = getRandomUserAgent();
+            requestHeaders['User-Agent'] = userAgent;
+            log('node.usingUserAgent', debug, { userAgent }, COMPONENTS.NODE_FETCH);
+        }
+        return requestHeaders;
+    }
+    /**
+     * 设置代理 (Set proxy)
+     * @param url 请求URL (Request URL)
+     * @param proxy 代理URL (Proxy URL)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @returns 代理Agent (Proxy agent)
+     */
+    static setupProxy(url, proxy, debug) {
+        if (!proxy)
+            return undefined;
+        let agent = undefined;
+        if (url.startsWith('https://')) {
+            agent = new HttpsProxyAgent(proxy);
+            log('node.usingHttpsProxy', debug, {}, COMPONENTS.NODE_FETCH);
+        }
+        else {
+            agent = new HttpProxyAgent(proxy);
+            log('node.usingHttpProxy', debug, {}, COMPONENTS.NODE_FETCH);
+        }
+        return agent;
+    }
+    /**
+     * 处理请求延迟 (Handle request delay)
+     * @param noDelay 是否禁用延迟 (Whether to disable delay)
+     * @param isRedirect 是否是重定向请求 (Whether it's a redirect request)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     */
+    static async handleDelay(noDelay, isRedirect, debug) {
+        if (!noDelay && isRedirect) {
+            await randomDelay();
+        }
+    }
+    /**
+     * 处理重定向URL (Handle redirect URL)
+     * @param location 重定向位置 (Redirect location)
+     * @param currentUrl 当前URL (Current URL)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @returns 完整的重定向URL (Complete redirect URL)
+     */
+    static buildRedirectUrl(location, currentUrl, debug) {
+        let redirectUrl = location;
+        if (location.startsWith('/')) {
+            const urlObj = new URL(currentUrl);
+            redirectUrl = `${urlObj.protocol}//${urlObj.host}${location}`;
+        }
+        else if (!location.startsWith('http')) {
+            redirectUrl = new URL(location, currentUrl).toString();
+        }
+        log('node.constructedFullRedirectUrl', debug, { redirectUrl }, COMPONENTS.NODE_FETCH);
+        return redirectUrl;
+    }
+    /**
+     * 处理错误响应 (Handle error response)
+     * @param response 响应对象 (Response object)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @returns Promise<never> 抛出错误 (Throws error)
+     */
+    static async handleErrorResponse(response, debug) {
+        log('node.errorResponse', debug, { status: response.status, statusText: response.statusText }, COMPONENTS.NODE_FETCH);
+        // 尝试读取错误响应体 (Try to read error response body)
+        let errorText = '';
+        try {
+            errorText = await response.text();
+            log('node.errorResponseBody', debug, { body: errorText.substring(0, 200) + (errorText.length > 200 ? '...' : '') }, COMPONENTS.NODE_FETCH);
+        }
+        catch (textError) {
+            log('node.errorReadingBody', debug, { error: String(textError) }, COMPONENTS.NODE_FETCH);
+        }
+        // 创建错误对象 (Create error object)
+        const error = new Error(`HTTP Error ${response.status}: ${response.statusText}`);
+        error.status = response.status;
+        error.statusText = response.statusText;
+        error.body = errorText;
+        throw error;
+    }
+    /**
+     * 处理请求错误 (Handle request error)
+     * @param error 错误对象 (Error object)
+     * @param fetchStart 请求开始时间 (Request start time)
+     * @param timeout 超时时间 (Timeout)
+     * @param redirectCount 重定向计数 (Redirect count)
+     * @param maxRedirects 最大重定向次数 (Maximum redirects)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @returns Promise<never> 抛出错误 (Throws error)
+     */
+    static handleRequestError(error, fetchStart, timeout, redirectCount, maxRedirects, debug) {
+        // 记录错误 (Log error)
+        log('node.fetchError', debug, { error: String(error) }, COMPONENTS.NODE_FETCH);
+        // 处理超时错误 (Handle timeout error)
+        if (error.name === 'AbortError') {
+            log('node.requestAborted', debug, { duration: Date.now() - fetchStart }, COMPONENTS.NODE_FETCH);
+            const timeoutError = new Error(`Request timeout after ${timeout}ms`);
+            timeoutError.code = 'ETIMEDOUT';
+            timeoutError.timeout = timeout;
+            throw timeoutError;
+        }
+        // 处理网络错误 (Handle network error)
+        if (error.code) {
+            log('node.networkError', debug, { code: error.code || error.name }, COMPONENTS.NODE_FETCH);
+            const networkError = new Error(`Network error: ${error.code || error.message}`);
+            networkError.code = error.code;
+            networkError.originalError = error;
+            throw networkError;
+        }
+        // 处理重定向错误 (Handle redirect error)
+        if (redirectCount >= maxRedirects) {
+            log('node.tooManyRedirects', debug, { redirects: maxRedirects }, COMPONENTS.NODE_FETCH);
+            const redirectError = new Error(`Too many redirects (${maxRedirects})`);
+            redirectError.code = 'EMAXREDIRECTS';
+            redirectError.redirects = redirectCount;
+            throw redirectError;
+        }
+        // 重新抛出其他错误 (Rethrow other errors)
+        throw error;
+    }
+    /**
+     * 执行带重定向处理的HTTP请求 (Execute HTTP request with redirect handling)
+     * 支持自动处理重定向、超时和代理 (Supports automatic handling of redirects, timeouts, and proxies)
+     */
+    static async fetchWithRedirects({ url, headers = {}, proxy, noDelay, timeout = 30000, // 默认30秒超时
+    maxRedirects = 10, // 最大重定向次数
+    useSystemProxy = true, // 是否使用系统代理
+    debug = false, // 是否启用调试模式
+     }) {
+        log('node.fetchingUrl', debug, { url }, COMPONENTS.NODE_FETCH);
+        // 处理代理设置 (Handle proxy settings)
+        const systemProxy = getSystemProxy(useSystemProxy, debug, COMPONENTS.NODE_FETCH);
+        const finalProxy = proxy || systemProxy;
+        if (finalProxy) {
+            log('node.usingProxy', debug, { proxy: finalProxy }, COMPONENTS.NODE_FETCH);
+        }
+        // 初始化重定向计数器 (Initialize redirect counter)
+        let redirectCount = 0;
+        let currentUrl = url;
+        // 记录请求开始时间 (Record request start time)
+        const fetchStart = Date.now();
+        // 创建AbortController用于超时控制 (Create AbortController for timeout control)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            // 处理重定向循环 (Handle redirect loop)
+            while (redirectCount < maxRedirects) {
+                log('node.fetchingUrl', debug, { url: currentUrl, redirect: redirectCount }, COMPONENTS.NODE_FETCH);
+                // 处理延迟 (Handle delay)
+                await this.handleDelay(noDelay, redirectCount > 0, debug);
+                // 准备请求头 (Prepare request headers)
+                const requestHeaders = this.prepareHeaders(headers, debug);
+                // 设置代理 (Set proxy)
+                const agent = this.setupProxy(currentUrl, finalProxy, debug);
+                // 准备请求选项 (Prepare request options)
+                const fetchOptions = {
+                    method: 'GET',
+                    headers: requestHeaders,
+                    timeout,
+                    signal: controller.signal,
+                };
+                if (agent) {
+                    fetchOptions.agent = agent;
+                }
+                // 记录请求详情 (Log request details)
+                log('node.requestDetails', debug, {
+                    url: currentUrl,
+                    method: fetchOptions.method || 'GET',
+                    headers: requestHeaders,
+                    proxy: finalProxy,
+                    timeout,
+                }, COMPONENTS.NODE_FETCH);
+                // 执行请求 (Execute request)
+                const response = await fetch(currentUrl, fetchOptions);
+                // 记录响应状态 (Log response status)
+                log('node.responseStatus', debug, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: Object.fromEntries(response.headers.entries()),
+                }, COMPONENTS.NODE_FETCH);
+                // 处理重定向 (Handle redirects)
+                if (response.status >= 300 && response.status < 400 && response.headers.has('location')) {
+                    redirectCount++;
+                    // 获取重定向URL (Get redirect URL)
+                    const location = response.headers.get('location');
+                    log('node.redirectingTo', debug, { location }, COMPONENTS.NODE_FETCH);
+                    // 构建完整的重定向URL (Build complete redirect URL)
+                    currentUrl = this.buildRedirectUrl(location, currentUrl, debug);
+                    continue;
+                }
+                // 如果响应成功，返回响应 (If response is successful, return response)
+                if (response.ok) {
+                    log('node.requestSuccess', debug, {}, COMPONENTS.NODE_FETCH);
+                    return response;
+                }
+                else {
+                    // 处理错误响应 (Handle error response)
+                    return await this.handleErrorResponse(response, debug);
+                }
+            }
+            // 如果达到最大重定向次数，抛出错误 (If maximum redirects reached, throw error)
+            throw new Error(`Too many redirects (${maxRedirects})`);
+        }
+        catch (error) {
+            // 处理请求错误 (Handle request error)
+            this.handleRequestError(error, fetchStart, timeout, redirectCount, maxRedirects, debug);
+        }
+        finally {
+            // 清除超时定时器 (Clear timeout timer)
+            clearTimeout(timeoutId);
+        }
+    }
+}