xiaoli-cli/plugins/operit/network_test.ts

/*
METADATA
{
    "name": "network_test",

    "display_name": {
        "zh": "网络测试",
        "en": "Network Test"
    },
    "category": "Network",
    "description": { "zh": "网络测试工具集合，提供基于OkHttp3的网络请求功能，包括GET、POST、PUT、DELETE请求方法，以及请求超时设置、重定向控制和拦截器管理。支持多种数据格式，便于测试API接口和网络连接性能。", "en": "Network testing tools based on OkHttp3. Provides GET/POST/PUT/DELETE requests, timeout settings, redirect control, and interceptor management. Supports multiple data formats for API testing and connectivity diagnostics." },
    "tools": [
        {
            "name": "http_get",
            "description": { "zh": "发送HTTP GET请求", "en": "Send an HTTP GET request." },
            "parameters": [
                {
                    "name": "url",
                    "description": { "zh": "请求URL", "en": "Request URL." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "headers",
                    "description": { "zh": "请求头", "en": "Request headers." },
                    "type": "object",
                    "required": false
                }
            ]
        },
        {
            "name": "http_post",
            "description": { "zh": "发送HTTP POST请求", "en": "Send an HTTP POST request." },
            "parameters": [
                {
                    "name": "url",
                    "description": { "zh": "请求URL", "en": "Request URL." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "body",
                    "description": { "zh": "请求体", "en": "Request body." },
                    "type": "object",
                    "required": true
                },
                {
                    "name": "headers",
                    "description": { "zh": "请求头", "en": "Request headers." },
                    "type": "object",
                    "required": false
                },
                {
                    "name": "body_type",
                    "description": { "zh": "请求体类型，支持'text'、'json'、'form'、'multipart'", "en": "Body type: 'text', 'json', 'form', or 'multipart'." },
                    "type": "string",
                    "required": false
                }
            ]
        },
        {
            "name": "http_put",
            "description": { "zh": "发送HTTP PUT请求", "en": "Send an HTTP PUT request." },
            "parameters": [
                {
                    "name": "url",
                    "description": { "zh": "请求URL", "en": "Request URL." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "body",
                    "description": { "zh": "请求体", "en": "Request body." },
                    "type": "object",
                    "required": true
                },
                {
                    "name": "headers",
                    "description": { "zh": "请求头", "en": "Request headers." },
                    "type": "object",
                    "required": false
                },
                {
                    "name": "body_type",
                    "description": { "zh": "请求体类型，支持'text'、'json'、'form'、'multipart'", "en": "Body type: 'text', 'json', 'form', or 'multipart'." },
                    "type": "string",
                    "required": false
                }
            ]
        },
        {
            "name": "http_delete",
            "description": { "zh": "发送HTTP DELETE请求", "en": "Send an HTTP DELETE request." },
            "parameters": [
                {
                    "name": "url",
                    "description": { "zh": "请求URL", "en": "Request URL." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "headers",
                    "description": { "zh": "请求头", "en": "Request headers." },
                    "type": "object",
                    "required": false
                }
            ]
        },
        {
            "name": "config_client",
            "description": { "zh": "配置HTTP客户端", "en": "Configure the HTTP client." },
            "parameters": [
                {
                    "name": "connect_timeout",
                    "description": { "zh": "连接超时时间(毫秒)", "en": "Connection timeout (milliseconds)." },
                    "type": "number",
                    "required": false
                },
                {
                    "name": "read_timeout",
                    "description": { "zh": "读取超时时间(毫秒)", "en": "Read timeout (milliseconds)." },
                    "type": "number",
                    "required": false
                },
                {
                    "name": "write_timeout",
                    "description": { "zh": "写入超时时间(毫秒)", "en": "Write timeout (milliseconds)." },
                    "type": "number",
                    "required": false
                },
                {
                    "name": "follow_redirects",
                    "description": { "zh": "是否跟随重定向", "en": "Whether to follow redirects." },
                    "type": "boolean",
                    "required": false
                },
                {
                    "name": "retry_on_failure",
                    "description": { "zh": "是否在连接失败时重试", "en": "Whether to retry on connection failure." },
                    "type": "boolean",
                    "required": false
                }
            ]
        },
        {
            "name": "ping_test",
            "description": { "zh": "测试与指定URL的网络连接", "en": "Test network connectivity to a specified URL." },
            "parameters": [
                {
                    "name": "url",
                    "description": { "zh": "要测试的URL", "en": "URL to test." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "count",
                    "description": { "zh": "测试次数", "en": "Number of test attempts." },
                    "type": "number",
                    "required": false
                }
            ]
        },
        {
            "name": "test_all",
            "description": { "zh": "运行所有网络测试", "en": "Run all network tests." },
            "parameters": []
        }
    ]
}*/

const networkTest = (function () {
    // 默认客户端
    let defaultClient = OkHttp.newClient();

    // 客户端配置
    let clientConfig: OkHttpConfig = {
        timeouts: {
            connect: 10000,
            read: 10000,
            write: 10000
        },
        followRedirects: true,
        retryOnConnectionFailure: true,
        interceptors: []
    };

    /**
     * 配置HTTP客户端
     * @param params - 配置参数
     */
    async function config_client(params: {
        connect_timeout?: number,
        read_timeout?: number,
        write_timeout?: number,
        follow_redirects?: boolean,
        retry_on_failure?: boolean
    }): Promise<any> {
        try {
            // 更新配置
            if (params.connect_timeout !== undefined) {
                clientConfig.timeouts.connect = params.connect_timeout;
            }
            if (params.read_timeout !== undefined) {
                clientConfig.timeouts.read = params.read_timeout;
            }
            if (params.write_timeout !== undefined) {
                clientConfig.timeouts.write = params.write_timeout;
            }
            if (params.follow_redirects !== undefined) {
                clientConfig.followRedirects = params.follow_redirects;
            }
            if (params.retry_on_failure !== undefined) {
                clientConfig.retryOnConnectionFailure = params.retry_on_failure;
            }

            // 创建新客户端
            const builder = OkHttp.newBuilder()
                .connectTimeout(clientConfig.timeouts.connect)
                .readTimeout(clientConfig.timeouts.read)
                .writeTimeout(clientConfig.timeouts.write)
                .followRedirects(clientConfig.followRedirects)
                .retryOnConnectionFailure(clientConfig.retryOnConnectionFailure);

            // 添加拦截器
            if (clientConfig.interceptors.length > 0) {
                for (const interceptor of clientConfig.interceptors) {
                    builder.addInterceptor(interceptor);
                }
            }

            // 构建客户端
            defaultClient = builder.build();

            return {
                success: true,
                message: "HTTP客户端配置已更新",
                config: {
                    ...clientConfig
                }
            };
        } catch (error) {
            throw new Error(`配置HTTP客户端失败: ${error.message}`);
        }
    }

    /**
     * 发送HTTP GET请求
     * @param params - 请求参数
     */
    async function http_get(params: { url: string, headers?: Record<string, string> }): Promise<any> {
        try {
            if (!params.url) {
                throw new Error("URL不能为空");
            }

            console.log(`发送GET请求: ${params.url}`);
            console.log(`请求头: ${JSON.stringify(params.headers || {})}`);

            // 准备请求
            const request = defaultClient.newRequest()
                .url(params.url)
                .method('GET');

            // 添加请求头
            if (params.headers) {
                request.headers(params.headers);
            }

            // 执行请求
            const response = await request.build().execute();

            // 返回结果
            const result = await formatResponse(response);

            // 额外输出重要的响应信息
            console.log(`\n🟢 GET请求完成: ${params.url}`);
            console.log(`🟢 状态码: ${result.status_code} ${result.status_message}`);
            if (result.json) {
                console.log(`🟢 返回数据类型: ${Array.isArray(result.json) ? '数组' : (typeof result.json === 'object' ? '对象' : typeof result.json)}`);
            }
            console.log(`🟢 响应大小: ${result.content_length} 字节\n`);

            return result;
        } catch (error) {
            throw new Error(`GET请求失败: ${error.message}`);
        }
    }

    /**
     * 发送HTTP POST请求
     * @param params - 请求参数
     */
    async function http_post(params: {
        url: string,
        body: any,
        headers?: Record<string, string>,
        body_type?: 'text' | 'json' | 'form' | 'multipart'
    }): Promise<any> {
        try {
            if (!params.url) {
                throw new Error("URL不能为空");
            }

            if (params.body === undefined) {
                throw new Error("请求体不能为空");
            }

            console.log(`发送POST请求: ${params.url}`);

            // 准备请求
            const request = defaultClient.newRequest()
                .url(params.url)
                .method('POST');

            // 添加请求头
            if (params.headers) {
                request.headers(params.headers);
            }

            // 添加请求体
            const bodyType = params.body_type || 'json';
            request.body(params.body, bodyType);

            // 执行请求
            const response = await request.build().execute();

            // 返回结果
            return await formatResponse(response);
        } catch (error) {
            throw new Error(`POST请求失败: ${error.message}`);
        }
    }

    /**
     * 发送HTTP PUT请求
     * @param params - 请求参数
     */
    async function http_put(params: {
        url: string,
        body: any,
        headers?: Record<string, string>,
        body_type?: 'text' | 'json' | 'form' | 'multipart'
    }): Promise<any> {
        try {
            if (!params.url) {
                throw new Error("URL不能为空");
            }

            if (params.body === undefined) {
                throw new Error("请求体不能为空");
            }

            console.log(`发送PUT请求: ${params.url}`);

            // 准备请求
            const request = defaultClient.newRequest()
                .url(params.url)
                .method('PUT');

            // 添加请求头
            if (params.headers) {
                request.headers(params.headers);
            }

            // 添加请求体
            const bodyType = params.body_type || 'json';
            request.body(params.body, bodyType);

            // 执行请求
            const response = await request.build().execute();

            // 返回结果
            return await formatResponse(response);
        } catch (error) {
            throw new Error(`PUT请求失败: ${error.message}`);
        }
    }

    /**
     * 发送HTTP DELETE请求
     * @param params - 请求参数
     */
    async function http_delete(params: { url: string, headers?: Record<string, string> }): Promise<any> {
        try {
            if (!params.url) {
                throw new Error("URL不能为空");
            }

            console.log(`发送DELETE请求: ${params.url}`);

            // 准备请求
            const request = defaultClient.newRequest()
                .url(params.url)
                .method('DELETE');

            // 添加请求头
            if (params.headers) {
                request.headers(params.headers);
            }

            // 执行请求
            const response = await request.build().execute();

            // 返回结果
            return await formatResponse(response);
        } catch (error) {
            throw new Error(`DELETE请求失败: ${error.message}`);
        }
    }

    /**
     * 格式化响应结果
     * @param response - OkHttp响应
     */
    async function formatResponse(response: OkHttpResponse): Promise<any> {
        try {
            let responseBody = '';
            let jsonData: any = undefined;

            // 获取响应文本
            responseBody = response.content;
            console.log(`\n===== 响应内容开始 =====`);
            console.log(`状态码: ${response.statusCode} ${response.statusMessage}`);
            console.log(`内容类型: ${response.contentType || '未知'}`);

            // 如果响应体不太长，完整显示
            if (responseBody && responseBody.length < 1000) {
                console.log(`响应体:\n${responseBody}`);
            } else if (responseBody) {
                console.log(`响应体(截断):\n${responseBody.substring(0, 500)}...`);
                console.log(`[完整长度: ${responseBody.length} 字符]`);
            } else {
                console.log(`响应体为空`);
            }

            // 尝试解析JSON
            if (response.contentType && response.contentType.includes('application/json')) {
                try {
                    jsonData = response.json();
                    if (jsonData) {
                        if (Array.isArray(jsonData)) {
                            console.log(`- 数组数据, 长度: ${(jsonData as any[]).length}`);
                            if ((jsonData as any[]).length > 0) {
                                console.log(`- 第一项样本: ${JSON.stringify(jsonData[0]).substring(0, 100)}${JSON.stringify(jsonData[0]).length > 100 ? '...' : ''}`);
                            }
                        } else if (typeof jsonData === 'object') {
                            const keys = Object.keys(jsonData);
                            console.log(`- 对象数据, 字段数: ${keys.length}`);
                            console.log(`- 字段列表: ${keys.slice(0, 5).join(', ')}${keys.length > 5 ? '...' : ''}`);
                            // 输出一个示例值
                            if (keys.length > 0) {
                                const sampleKey = keys[0];
                                const sampleValue = JSON.stringify(jsonData[sampleKey]);
                                console.log(`- 示例 "${sampleKey}": ${sampleValue.substring(0, 60)}${sampleValue.length > 60 ? '...' : ''}`);
                            }

                            // 输出完整的JSON格式化数据
                            console.log(`\nJSON完整数据:`);
                            console.log(JSON.stringify(jsonData, undefined, 2));
                        } else {
                            console.log(`- 基本类型数据: ${JSON.stringify(jsonData).substring(0, 100)}`);
                        }
                    }
                } catch (e) {
                    console.warn("响应内容不是有效的JSON格式");
                }
            }
            console.log(`===== 响应内容结束 =====\n`);

            return {
                success: response.isSuccessful(),
                status_code: response.statusCode,
                status_message: response.statusMessage,
                headers: response.headers,
                content_type: response.contentType,
                content_length: response.size,
                body: responseBody,
                json: jsonData,
                time_info: {
                    timestamp: new Date().toISOString()
                }
            };
        } catch (error) {
            console.error(`格式化响应出错: ${error.message}`);
            return {
                success: false,
                error: `格式化响应出错: ${error.message}`
            };
        }
    }

    /**
     * 测试与指定URL的网络连接
     * @param params - 测试参数
     */
    async function ping_test(params: { url: string, count?: number }): Promise<any> {
        try {
            if (!params.url) {
                throw new Error("URL不能为空");
            }

            const count = params.count || 3;
            const results: Array<{
                attempt: number;
                success: boolean;
                time_ms: number;
                status?: number;
                error?: string;
            }> = [];
            let totalTime = 0;
            let successCount = 0;
            let failCount = 0;

            console.log(`开始Ping测试: ${params.url}, 次数: ${count}`);

            for (let i = 0; i < count; i++) {
                const startTime = Date.now();
                try {
                    // 发送简单的HEAD请求来测试连接
                    const request = defaultClient.newRequest()
                        .url(params.url)
                        .method('HEAD')
                        .build();

                    const response = await request.execute();
                    const endTime = Date.now();
                    const elapsed = endTime - startTime;

                    totalTime += elapsed;
                    successCount++;

                    results.push({
                        attempt: i + 1,
                        success: true,
                        time_ms: elapsed,
                        status: response.statusCode
                    });

                    console.log(`Ping #${i + 1}: ${elapsed}ms, 状态: ${response.statusCode}`);

                    // 等待一小段时间后再发送下一个请求
                    if (i < count - 1) {
                        await sleep(500);
                    }
                } catch (error) {
                    const endTime = Date.now();
                    const elapsed = endTime - startTime;
                    failCount++;

                    results.push({
                        attempt: i + 1,
                        success: false,
                        time_ms: elapsed,
                        error: error.message
                    });

                    console.log(`Ping #${i + 1}: 失败, 错误: ${error.message}`);

                    // 等待一小段时间后再发送下一个请求
                    if (i < count - 1) {
                        await sleep(500);
                    }
                }
            }

            const avgTime = successCount > 0 ? totalTime / successCount : 0;

            return {
                url: params.url,
                success: successCount > 0,
                summary: {
                    total_count: count,
                    success_count: successCount,
                    fail_count: failCount,
                    success_rate: `${(successCount / count * 100).toFixed(1)}%`,
                    average_time: `${avgTime.toFixed(2)}ms`
                },
                detail_results: results
            };
        } catch (error) {
            throw new Error(`Ping测试失败: ${error.message}`);
        }
    }

    /**
     * 等待指定的毫秒数
     * @param ms 等待的毫秒数
     */
    async function sleep(ms: number | string): Promise<void> {
        const sleepTime = Number(ms);
        if (isNaN(sleepTime)) {
            throw new Error("无效的等待时间");
        }
        return new Promise(resolve => setTimeout(resolve, sleepTime));
    }

    /**
     * 测试所有网络功能
     */
    async function test_all(): Promise<any> {
        try {
            console.log("开始网络功能测试...");

            const results: {
                config?: any;
                ping?: any;
                get?: any;
                post?: any;
                put?: any;
                delete?: any;
            } = {};

            // 1. 测试客户端配置
            console.log("测试客户端配置...");
            try {
                const configResult = await config_client({
                    connect_timeout: 8000,
                    read_timeout: 8000,
                    write_timeout: 8000,
                    follow_redirects: true,
                    retry_on_failure: true
                });
                results.config = configResult;
                console.log("✓ 客户端配置成功");
            } catch (error) {
                results.config = { error: `客户端配置失败: ${error.message}` };
                console.log("✗ 客户端配置失败");
            }

            // 2. 测试连接
            console.log("测试网络连接...");
            try {
                const pingResult = await ping_test({
                    url: "https://httpbin.org",
                    count: 2
                });
                results.ping = pingResult;
                console.log("✓ Ping测试成功");
            } catch (error) {
                results.ping = { error: `Ping测试失败: ${error.message}` };
                console.log("✗ Ping测试失败");
            }

            // 3. 测试GET请求
            console.log("测试GET请求...");
            try {
                const getResult = await http_get({
                    url: "https://httpbin.org/get",
                    headers: {
                        "User-Agent": "OkHttp-Network-Tester/1.0"
                    }
                });
                results.get = getResult;
                console.log("✓ GET请求成功");

                // 显示更多关于GET响应的信息
                console.log("\n====== GET请求结果摘要 ======");
                console.log(`状态: ${getResult.status_code} ${getResult.status_message}`);

                // 如果有JSON数据，显示一些关键信息
                if (getResult.json) {
                    console.log("GET响应数据预览:");

                    // httpbin.org/get 通常会返回请求信息的镜像
                    if (getResult.json.headers) {
                        console.log("- 发送的请求头:");
                        Object.keys(getResult.json.headers).forEach(key => {
                            console.log(`  ${key}: ${getResult.json.headers[key]}`);
                        });
                    }

                    if (getResult.json.url) {
                        console.log(`- 请求URL: ${getResult.json.url}`);
                    }

                    if (getResult.json.origin) {
                        console.log(`- 来源IP: ${getResult.json.origin}`);
                    }
                }
                console.log("===============================\n");
            } catch (error) {
                results.get = { error: `GET请求失败: ${error.message}` };
                console.log("✗ GET请求失败");
            }

            // 4. 测试POST请求
            console.log("测试POST请求...");
            try {
                const postResult = await http_post({
                    url: "https://httpbin.org/post",
                    body: {
                        name: "OkHttp网络测试",
                        timestamp: new Date().toISOString()
                    },
                    headers: {
                        "Content-Type": "application/json",
                        "User-Agent": "OkHttp-Network-Tester/1.0"
                    }
                });
                results.post = postResult;
                console.log("✓ POST请求成功");
            } catch (error) {
                results.post = { error: `POST请求失败: ${error.message}` };
                console.log("✗ POST请求失败");
            }

            // 5. 测试PUT请求
            console.log("测试PUT请求...");
            try {
                const putResult = await http_put({
                    url: "https://httpbin.org/put",
                    body: {
                        name: "OkHttp网络测试",
                        timestamp: new Date().toISOString(),
                        action: "update"
                    },
                    headers: {
                        "Content-Type": "application/json",
                        "User-Agent": "OkHttp-Network-Tester/1.0"
                    }
                });
                results.put = putResult;
                console.log("✓ PUT请求成功");
            } catch (error) {
                results.put = { error: `PUT请求失败: ${error.message}` };
                console.log("✗ PUT请求失败");
            }

            // 6. 测试DELETE请求
            console.log("测试DELETE请求...");
            try {
                const deleteResult = await http_delete({
                    url: "https://httpbin.org/delete",
                    headers: {
                        "User-Agent": "OkHttp-Network-Tester/1.0"
                    }
                });
                results.delete = deleteResult;
                console.log("✓ DELETE请求成功");
            } catch (error) {
                results.delete = { error: `DELETE请求失败: ${error.message}` };
                console.log("✗ DELETE请求失败");
            }

            // 返回所有测试结果
            return {
                message: "网络功能测试完成",
                test_results: results,
                timestamp: new Date().toISOString(),
                summary: "测试了各种网络功能，包括配置、Ping测试和HTTP请求。请查看各功能的测试结果。"
            };
        } catch (error) {
            return {
                success: false,
                message: `测试过程中发生错误: ${error.message}`
            };
        }
    }

    /**
     * 包装函数 - 统一处理所有network_test函数的返回结果
     * @param func 原始函数
     * @param params 函数参数
     * @param successMessage 成功消息
     * @param failMessage 失败消息
     * @param additionalInfo 附加信息(可选)
     */
    async function network_wrap<T>(
        func: (params: any) => Promise<any>,
        params: any,
        successMessage: string,
        failMessage: string,
        additionalInfo: string = ""
    ): Promise<void> {
        try {
            console.log(`开始执行函数: ${func.name || '匿名函数'}`);
            console.log(`参数:`, JSON.stringify(params, undefined, 2));

            // 执行原始函数
            const result = await func(params);

            console.log(`函数 ${func.name || '匿名函数'} 执行结果:`, JSON.stringify(result, undefined, 2));

            // 如果原始函数已经调用了complete，就不需要再次调用
            if (result === undefined) return;

            // 根据结果类型处理
            if (typeof result === "boolean") {
                // 布尔类型结果
                complete({
                    success: result,
                    message: result ? successMessage : failMessage,
                    additionalInfo: additionalInfo
                });
            } else {
                // 数据类型结果
                complete({
                    success: true,
                    message: successMessage,
                    additionalInfo: additionalInfo,
                    data: result
                });
            }
        } catch (error) {
            // 详细记录错误信息
            console.error(`函数 ${func.name || '匿名函数'} 执行失败!`);
            console.error(`错误信息: ${error.message}`);
            console.error(`错误堆栈: ${error.stack}`);

            // 处理错误
            complete({
                success: false,
                message: `${failMessage}: ${error.message}`,
                additionalInfo: additionalInfo,
                error_stack: error.stack
            });
        }
    }

    return {
        config_client: async (params) => await network_wrap(
            config_client,
            params,
            "配置HTTP客户端成功",
            "配置HTTP客户端失败"
        ),
        http_get: async (params) => await network_wrap(
            http_get,
            params,
            "GET请求成功",
            "GET请求失败"
        ),
        http_post: async (params) => await network_wrap(
            http_post,
            params,
            "POST请求成功",
            "POST请求失败"
        ),
        http_put: async (params) => await network_wrap(
            http_put,
            params,
            "PUT请求成功",
            "PUT请求失败"
        ),
        http_delete: async (params) => await network_wrap(
            http_delete,
            params,
            "DELETE请求成功",
            "DELETE请求失败"
        ),
        ping_test: async (params) => await network_wrap(
            ping_test,
            params,
            "网络连接测试成功",
            "网络连接测试失败"
        ),
        test_all: async () => await network_wrap(
            test_all,
            {},
            "网络功能测试完成",
            "网络功能测试失败"
        )
    };
})();

// 导出所有函数
exports.config_client = networkTest.config_client;
exports.http_get = networkTest.http_get;
exports.http_post = networkTest.http_post;
exports.http_put = networkTest.http_put;
exports.http_delete = networkTest.http_delete;
exports.ping_test = networkTest.ping_test;
exports.test_all = networkTest.test_all;
exports.main = networkTest.test_all;