runner-runtime 1.0.8

package/events/api.js

@@ -0,0 +1,2280 @@
+const FileType = require("file-type"),
+    contentDisposition = require("content-disposition"),
+    aTools = require("apipost-tools"),
+    isSvg = require("is-svg"),
+    JSONbig = require("json-bigint")({ storeAsString: true }),
+    stripJsonComments = require("strip-json-comments"),
+    mime = require("mime"),
+    { mockExp } = require('exp-mock'),
+    tough = require("tough-cookie"),
+    Buffer = require("buffer/").Buffer,
+    isImage = require("is-image");
+const { getAPIFromCollection, smartUrlJoin, replace2RegExp, getParentTargetIDs, base64toCacheFile, getInsideVariables, getCaseInsensitive } = require('../libs/utils'),
+    _ = require('lodash');
+const sdk = require("postman-collection"),
+    Url = sdk.Url,
+    PostmanEvent = sdk.Event;
+const Mock = require('mockjs5-pro');
+const { v4: uuidv4 } = require("uuid");
+
+const fs = require("fs");
+const { minimatch } = require("minimatch");
+const runtime = require("postman-runtime-pro");
+
+// 将api转postman请求参数
+const convert2PostmanRequest = (request, option) => {
+    const pmRequest = {};
+    const { systemConfigs } = _.get(option, 'system_configs', {});
+
+    // 自动识别请求参数的Mock变量
+    const autoReplaceMockVar = (para) => {
+        try {
+            return _.toInteger(systemConfigs?.auto_gen_mock_url) > 0 ? Mock.mock(para) : para;
+        } catch (e) {
+            return para;
+        }
+    };
+
+    // 处理 url
+    const raw = autoReplaceMockVar(_.get(request, "request.url") || _.get(request, "url"));
+    const uri = new Url(raw);
+
+    // 清除原有query参数
+    try {
+        uri?.query.clear();
+    } catch (e) { }
+
+    // 遍历重置query参数
+    const queryAddEqual = _.toInteger(
+        _.get(request, "request.query.query_add_equal") || -1
+    );
+    _.forEach(_.get(request, "request.query.parameter"), (item) => {
+        if (_.isObject(item) && item?.is_checked > 0) {
+            let { key, value } = item;
+            key = String(autoReplaceMockVar(_.trim(key)));
+            value = String(autoReplaceMockVar(value));
+
+            if (key != "") {
+                if (value == "" && queryAddEqual < 1) {
+                    // 不拼接 = 号
+                    uri?.query?.members?.push(new sdk.QueryParam({ key, value: null }));
+                } else {
+                    uri?.query?.members?.push(new sdk.QueryParam({ key, value, }));
+                }
+            }
+        }
+    }
+    );
+
+    // path 参数
+    const uriVariable = [];
+
+    if (_.isArray(_.get(uri, "path"))) {
+        const transformed = _.map(_.get(uri, "path"), (item) => {
+            if (_.startsWith(item, "{") && !_.startsWith(item, "{{") && _.endsWith(item, "}") && !_.endsWith(item, "}}")) {
+                return ":" + item.slice(1, -1);
+            }
+            return item; // 不需要替换的元素直接返回
+        });
+
+        _.set(uri, "path", transformed);
+    }
+    _.forEach(
+        _.get(request, "request.restful.parameter"), (item) => {
+            if (_.isObject(item) && item?.is_checked > 0) {
+                let { key, value } = item;
+                key = autoReplaceMockVar(_.trim(key));
+                value = autoReplaceMockVar(value);
+
+                if (key != "") {
+                    uriVariable.push({ key, value });
+                }
+            }
+        }
+    );
+
+    if (_.isUndefined(uri?.protocol)) {
+        const varPattern = /^{{.*}}/;
+        if (!_.startsWith(_.first(uri?.host), "{{") && !varPattern.test(_.first(uri?.host))) {
+            _.set(uri, "protocol", "http");
+        }
+    }
+
+    const rawUrl = String(uri);
+
+    if (uri?.query?.members?.length > 0) {
+        try {
+            _.set(uri, "query", uri?.query?.toJSON());
+        } catch (e) {
+            _.set(uri, "query", uri?.query?.toObject());
+        }
+    } else {
+        _.set(uri, "query", undefined);
+    }
+
+    _.set(pmRequest, "url", {
+        raw: rawUrl,
+        variable: uriVariable,
+        ...uri,
+    });
+
+    // 处理协议
+    _.set(pmRequest, "protocol", _.get(request, "protocol") || "http/1.1");
+
+    // 处理 method
+    _.set(pmRequest, "method", _.get(request, "method") || "GET");
+
+    // 处理认证
+    const auth = {};
+    const authType = _.get(request, "request.auth.type") || "noauth";
+
+    if (_.isString(authType) && authType != "noauth" && authType != "inherit") {
+        switch (authType) {
+            case "kv":
+                _.assign(auth, {
+                    type: "apikey",
+                    apikey: [
+                        {
+                            key: "in",
+                            value: _.get(request, `request.auth.kv.in`) || "header",
+                            type: "string",
+                        },
+                        {
+                            key: "value",
+                            value:
+                                autoReplaceMockVar(_.get(request, `request.auth.kv.value`)) || "",
+                            type: "string",
+                        },
+                        {
+                            key: "key",
+                            value:
+                                autoReplaceMockVar(_.get(request, `request.auth.kv.key`)) || "",
+                            type: "string",
+                        },
+                    ],
+                });
+                break;
+            case "basic":
+                _.assign(auth, {
+                    type: "basic",
+                    basic: [
+                        {
+                            key: "password",
+                            value:
+                                autoReplaceMockVar(_.get(request, `request.auth.basic.password`)) || "",
+                            type: "string",
+                        },
+                        {
+                            key: "username",
+                            value:
+                                autoReplaceMockVar(_.get(request, `request.auth.basic.username`)) || "",
+                            type: "string",
+                        },
+                    ],
+                });
+                break;
+            case "bearer":
+                _.assign(auth, {
+                    type: "bearer",
+                    bearer: [
+                        {
+                            key: "token",
+                            value:
+                                autoReplaceMockVar(_.get(request, `request.auth.bearer.key`)) ||
+                                "",
+                            type: "string",
+                        },
+                    ],
+                });
+                break;
+            case "digest":
+                const keyMap = {
+                    username: "username",
+                    password: "password",
+                    realm: "realm",
+                    nonce: "nonce",
+                    algorithm: "algorithm",
+                    qop: "qop",
+                    opaque: "opaque",
+                    nc: "nonceCount",
+                    cnonce: "clientNonce",
+                    disableRetryRequest: "disableRetryRequest",
+                };
+                _.set(auth, "type", authType);
+                _.set(auth, authType, []);
+
+                _.forEach(_.get(request, `request.auth.${authType}`), (val, key) => {
+                    key = keyMap[autoReplaceMockVar(key)];
+                    if (_.isString(val)) {
+                        val = autoReplaceMockVar(val);
+                    }
+
+                    const value = _.isBoolean(val) ? val : (_.isInteger(val) ? !!val : _.isString(val) ? val : "");
+                    const type = (_.isInteger(val) || _.isBoolean(val)) ? "boolean" : "string";
+                    auth[authType].push({ key, value, type });
+                }
+                );
+
+                if (_.keys(_.get(request, `request.auth.${authType}`)).indexOf("disableRetryRequest") == -1) {
+                    auth[authType].push({
+                        key: "disableRetryRequest",
+                        value: false,
+                        type: "boolean",
+                    });
+                }
+                break;
+            case "hawk":
+            case "oauth1":
+            case "oauth2":
+            case "awsv4":
+            case "ntlm":
+            case "jwt":
+            case "asap":
+            case "edgegrid": // TODO 将增加 asap和jwt，需前端增加相关参数
+                _.set(auth, "type", authType);
+                _.set(auth, authType, []);
+                _.forEach(_.get(request, `request.auth.${authType}`), (val, key) => {
+                    if (_.isString(val)) {
+                        val = autoReplaceMockVar(val);
+                    }
+
+                    key = autoReplaceMockVar(key);
+                    const value = _.isBoolean(val) ? val : (_.isInteger(val) ? !!val : _.isString(val) ? val : "");
+                    const type = (_.isInteger(val) || _.isBoolean(val)) ? "boolean" : "string";
+                    auth[authType].push({ key, value, type });
+                }
+                );
+                break;
+        }
+    }
+
+    !_.isEmpty(auth) && _.set(pmRequest, "auth", auth);
+
+    // 处理 header
+    const header = [];
+    _.forEach(_.get(request, "request.header.parameter"), (item) => {
+        if (_.isObject(item) && item?.is_checked > 0) {
+            let disabled = item?.is_checked > 0 ? false : true;
+            let { key, value } = item;
+            key = autoReplaceMockVar(_.trim(key));
+            value = autoReplaceMockVar(value);
+            key != "" && header.push({ key, value, disabled });
+        }
+    }
+    );
+
+    let accessToken = ""; // 用于oauth2的access_token
+    if (auth?.type == "oauth2") {
+        if (_.isArray(auth?.oauth2)) {
+            const addTokenItem = _.find(auth.oauth2, { key: "addTokenTo" });
+            const headerPrefixItem = _.find(auth.oauth2, { key: "headerPrefix" });
+            const accessTokenItem = _.find(auth.oauth2, { key: "access_token" });
+            if (accessTokenItem?.value) {
+                accessToken = accessTokenItem.value;
+                if (headerPrefixItem?.value) {
+                    accessToken = headerPrefixItem.value + " " + accessToken;
+                } else {
+                    accessToken = "Bearer " + accessToken;
+                }
+                if (addTokenItem?.value == "header") {
+                    header.push({ key: "Authorization", value: accessToken, disabled: false });
+                    accessToken = ""; //设置完成自动清空
+                } else if (addTokenItem?.value == "queryParams") {
+                    accessToken = accessTokenItem.value; //重置为最新
+                    const oldUri = pmRequest.url.raw;
+                    const urlObj = new URL(oldUri);
+                    urlObj.searchParams.set('access_token', accessToken);
+                    const query = pmRequest.url.query || [];
+                    query.push({ key: "access_token", value: accessToken });
+                    _.set(pmRequest, "url", {
+                        ...pmRequest.url,
+                        raw: urlObj.toString(),
+                        query: query,
+                    });
+                    accessToken = ""; //设置完成自动清空
+                } else {
+                    accessToken = ""; //不添加
+                }
+            }
+        }
+    }
+
+    const keyMap = new Map();
+    const duplicates = [];
+
+    // 遍历header数组，记录每个key的最新item
+    _.forEach(header, (item, index) => {
+        const lowerKey = item.key.toLowerCase();
+        if (keyMap.has(lowerKey)) {
+            duplicates.push(keyMap.get(lowerKey));
+        }
+        keyMap.set(lowerKey, index);
+    });
+
+    // 如果有重复项，倒序剔除这些index的值
+    if (duplicates.length > 0) {
+        _.forEachRight(duplicates, (dupIndex) => {
+            if (dupIndex > -1) {
+                header.splice(dupIndex, 1);
+            }
+        });
+    }
+
+    _.set(pmRequest, "header", header);
+
+    // 处理 cookie
+    try {
+        if (pmRequest?.url?.raw != "") {
+            let cookieUrlParse = {};
+
+            if (_.isString(_.get(request, 'initVarReplacedUrl')) && !_.isEmpty(_.get(request, 'initVarReplacedUrl'))) {
+                cookieUrlParse = new Url(_.get(request, 'initVarReplacedUrl'))
+            }
+
+            const cookieStr = [];
+
+            _.forEach(_.get(request, "request.cookie.parameter"), (item) => {
+                if (_.isObject(item)) {
+                    let name = encodeURIComponentUnique(
+                        autoReplaceMockVar(item.key || item.name)
+                    );
+
+                    let value = autoReplaceMockVar(item.value);
+
+                    if (_.isUndefined(_.get(request, "request.cookie.cookie_encode")) || _.parseInt(_.get(request, "request.cookie.cookie_encode")) > 0) {
+                        value = encodeURIComponentUnique(value);
+                    }
+
+                    let cookie = _.assign(item, { key: name, name, value });
+                    let host = !_.isEmpty(pmRequest?.url?.host) ? _.join(pmRequest?.url?.host, ".") : pmRequest?.url?.raw;
+                    let urlPath = pmRequest?.url?.path;
+
+                    if (!_.isEmpty(cookieUrlParse)) {
+                        host = !_.isEmpty(cookieUrlParse.host) ? _.join(cookieUrlParse.host, ".") : _.get(request, 'initVarReplacedUrl');
+                        urlPath = cookieUrlParse.path
+                    }
+
+                    let pathStr = _.join(urlPath, "/");
+
+                    if (!_.startsWith(pathStr, '/') && _.startsWith(cookie?.path, '/')) {
+                        pathStr = `/${pathStr}`;
+                    }
+
+                    if (!_.endsWith(pathStr, '/') && _.endsWith(cookie?.path, '/')) {
+                        pathStr = `${pathStr}/`;
+                    }
+
+                    if ((_.isUndefined(cookie?.domain) || minimatch(host, cookie?.domain) || _.endsWith(host, cookie?.domain)) && (_.isUndefined(cookie?.path) || cookie?.path == '/' || _.startsWith(pathStr || "/", cookie?.path)) && (_.isUndefined(cookie?.expires) || _.gt(new Date(String(cookie?.expires)), new Date()))) {
+                        cookieStr.push(`${cookie.name}=${cookie.value}`);
+                    }
+                }
+            }
+            );
+
+            if (!_.isEmpty(cookieStr)) {
+                const foundItem = _.find(
+                    pmRequest.header,
+                    (item) => _.toLower(item.key) === _.toLower("cookie")
+                );
+
+                if (foundItem) {
+                    foundItem.value = _.join(cookieStr, ";");
+                } else {
+                    pmRequest.header.push({
+                        key: "Cookie",
+                        value: _.join(cookieStr, ";"),
+                    });
+                }
+            }
+        }
+    } catch (e) { }
+
+    // 处理body
+    const body = {};
+    const bodyMode = _.get(request, "request.body.mode") || "none";
+
+    if (_.isString(bodyMode) && bodyMode != "none") {
+        const modeMap = {
+            "form-data": "formdata",
+            plain: "text",
+            binary: "file",
+            msgpack: "msgpack",
+        };
+
+        switch (bodyMode) {
+            case "form-data":
+            case "urlencoded":
+                _.set(body, "mode", modeMap[bodyMode] ? modeMap[bodyMode] : bodyMode);
+                _.set(body, body.mode, []);
+
+                const parameter = _.get(request, `request.body.parameter`);
+
+                _.forEach(parameter, (item) => {
+                    if (_.isObject(item)) {
+                        if (item.is_checked > 0 && autoReplaceMockVar(item.key) != '') {
+                            if (bodyMode == "form-data" && item.field_type == "File") {
+                                const src = base64toCacheFile(
+                                    item.key,
+                                    item.value,
+                                    item.file_base64,
+                                    request?.target_id
+                                );
+                                body[body.mode].push({
+                                    key: autoReplaceMockVar(item.key),
+                                    src,
+                                    type: "file",
+                                    disabled: false,
+                                });
+                            } else {
+                                if (bodyMode == "form-data" && item.content_type != "") {
+                                    body[body.mode].push({
+                                        key: autoReplaceMockVar(item.key),
+                                        value: autoReplaceMockVar(item.value),
+                                        type: "text",
+                                        disabled: false,
+                                        contentType: item.content_type,
+                                    });
+                                } else {
+                                    body[body.mode].push({
+                                        key: autoReplaceMockVar(item.key),
+                                        value: autoReplaceMockVar(item.value),
+                                        type: "text",
+                                        disabled: false,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                );
+                break;
+            case "binary":
+                const src = base64toCacheFile(
+                    "binary",
+                    _.get(request, `request.body.binary.file_path`),
+                    _.get(request, `request.body.binary.data_url`),
+                    request?.target_id
+                );
+                _.assign(body, {
+                    mode: "file",
+                    file: {
+                        src,
+                    },
+                });
+                break;
+            default:
+                let raw = autoReplaceMockVar(_.get(request, `request.body.raw`));
+
+                if (bodyMode == "msgpack") {
+                    const msgpack = require("msgpack5")();
+                    try {
+                        raw = msgpack.encode(JSONbig.parse(stripJsonComments(raw))).slice();
+                        Object.setPrototypeOf(raw, Object.getPrototypeOf({}));
+                    } catch (e) { }
+
+                    const foundItem = _.find(
+                        pmRequest.header,
+                        (item) => _.toLower(item.key) === _.toLower("content-type")
+                    );
+
+                    if (foundItem) {
+                        foundItem.value = "application/msgpack";
+                    } else {
+                        pmRequest.header.push({
+                            key: "content-type",
+                            value: "application/msgpack",
+                        });
+                    }
+                } else if (bodyMode == "json" && option?.request_param_auto_json > 0) {
+                    try {
+                        raw = JSONbig.stringify(JSONbig.parse(stripJsonComments(raw)));
+                        Object.setPrototypeOf(raw, Object.getPrototypeOf({}));
+                    } catch (e) { }
+                }
+
+                _.assign(body, {
+                    mode: "raw",
+                    raw,
+                    options: {
+                        raw: {
+                            language: modeMap[bodyMode] ? modeMap[bodyMode] : bodyMode,
+                        },
+                    },
+                });
+                break;
+        }
+    }
+
+    !_.isEmpty(body) && _.set(pmRequest, "body", body);
+
+    return pmRequest;
+}
+
+// 转postman请求选项
+const convert2PostmanOptions = (request, option, variables) => {
+    // 请求信息
+    const { requestJson } = request;
+
+    // 创建迭代数据
+    const iterationData = _.get(variables, 'iterationData');
+    const data = [iterationData];
+
+    // 初始化 environment
+    const envVariables = [];
+    _.forEach(_.get(variables, "environment"), (value, key) => {
+        envVariables.push({
+            value,
+            key,
+            type: "any",
+            enabled: true,
+        });
+    });
+
+    const environment = new sdk.VariableScope({
+        values: envVariables,
+    });
+
+    // 初始化 globals
+    const globalsVariables = [];
+    _.forEach(_.defaults(_.get(variables, "globals") || {}, getInsideVariables()), (value, key) => {
+        globalsVariables.push({
+            value,
+            key,
+            type: "any",
+            enabled: true,
+        });
+    }
+    );
+
+    // 创建一个全局变量对象
+    const globals = new sdk.VariableScope({
+        values: globalsVariables,
+    });
+
+    const requester = {
+        strictSSL: false,
+        protocolVersion: requestJson?.protocol == 'http/1.1' ? 'http1' : 'http2',
+        timings: true,
+        verbose: false,
+        implicitCacheControl: true,
+        implicitTraceHeader: false,
+        followOriginalHttpMethod: _.get(option, "system_configs.follow_original_method") > 0 ? true : false,
+        followRedirects: _.get(option, "system_configs.auto_redirect") > 0 ? true : false,
+        maxRedirects: _.max([_.toInteger(_.get(option, "system_configs.max_redirect_time")), 5])
+    };
+
+    // 设置extendedRootCA证书
+    if (_.get(option, "system_configs.ca_cert.open") > 0 && _.trim(_.get(option, "system_configs.ca_cert.path")) != "") {
+        _.set(requester, `extendedRootCA`, _.trim(_.get(option, "system_configs.ca_cert.path")));
+    }
+
+    // 设置客户端证书
+    const certificates = [];
+    _.forEach(_.get(option, "system_configs.client_cert"), (cert, host) => {
+        const uri = new Url(host);
+        if (_.isObject(cert)) {
+            if (uri.port <= 0) {
+                host = `${uri.protocol}://${_.join(uri.host, ".")}:443`;
+            }
+
+            ['key', 'crt', 'pfx'].forEach((type) => {
+                let fileUrl = _.get(cert, `${type}.file_url`);
+
+                if (_.isEmpty(fileUrl)) {
+                    if (!_.isEmpty(_.get(cert, `${type}.file_base64`))) {
+                        fileUrl = base64toCacheFile(
+                            _.get(cert, `${type}.file_name`),
+                            _.get(cert, `${type}.file_name`),
+                            _.get(cert, `${type}.file_base64`),
+                            uuidv4()
+                        )
+                    }
+                }
+
+                if (!_.isEmpty(fileUrl)) {
+                    try {
+                        fs.statSync(fileUrl);
+                        _.set(cert, `${type}.file_url`, fileUrl);
+                    } catch (e) { }
+                }
+            })
+
+            const certObj = {
+                name: `Client cert for ${host}`,
+                matches: [host, `${host}/*`],
+                passphrase: cert?.password,
+            };
+
+            ['key', 'crt', 'pfx'].forEach((type) => {
+                if (!_.isEmpty(_.get(cert, `${type}.file_url`))) {
+                    _.set(certObj, type == 'crt' ? "cert" : type, { src: _.get(cert, `${type}.file_url`) })
+                }
+            })
+
+            certificates.push(certObj);
+        }
+    }
+    );
+    let requestTimeout = _.toInteger(_.get(option, "system_configs.send_timeout"));
+
+    // fix 请求超时时间除0外，最大值为一周，0为永不超时
+    if (!_.inRange(requestTimeout, 0, 604800)) {
+        requestTimeout = 0;
+    }
+
+    const options = {
+        timeout: {
+            request: requestTimeout,
+            script: 0,
+            global: 0,
+        },
+        delay: {
+            item: 0,
+            iteration: 0,
+        },
+        iterationCount: 1,
+        fileResolver: require("fs"),
+        data,
+        environment,
+        globals,
+        requester,
+        systemProxy: async function (url, callback) {
+            try {
+                // 设置代理
+                const proxy = {}, urlParsed = new Url(url), uriHost = _.toLower(_.join(urlParsed?.host, "."));
+
+                if (_.get(option, "system_configs.proxy.type") == 1) {
+                    // 自定义代理
+                    const match = _.get(option, "system_configs.proxy.auth.host").match(
+                        /(([^:]+):(\d+))/
+                    );
+
+                    if (_.isArray(match) && _.toInteger(match[3]) > 0) {
+                        // 检查当前host是否匹配 bypass
+                        let bypass = _.get(option, "system_configs.proxy.bypass");
+
+                        if (_.isString(bypass)) {
+                            bypass = bypass.split(",");
+                        }
+
+                        let bypassMatch = _.find(bypass, (o) => {
+                            return minimatch(uriHost, o);
+                        });
+
+                        // 检查当前协议是否匹配 protocol
+                        let protocols = _.get(option, "system_configs.proxy.protocols");
+
+                        if (_.isString(protocols)) {
+                            protocols = protocols.split(",");
+                        }
+
+                        let protocolMatch = _.find(protocols, (o) => {
+                            return (_.toLower(urlParsed?.protocol) || "http") == _.toLower(o);
+                        });
+
+                        // 不匹配 bypass 且 匹配 protocol
+                        if (!bypassMatch && protocolMatch) {
+                            _.set(proxy, "host", match[2]);
+                            _.set(proxy, "port", _.toInteger(match[3]));
+                        }
+                    }
+                } else if (_.get(option, "system_configs.proxy.type") == -1) {
+                    // 获取系统代理
+                    let noProxy = _.isString(_.get(process, "env.NO_PROXY")) && _.get(option, "system_configs.proxy.envfirst") > 0 ? String(_.get(process, "env.NO_PROXY")).split(",") : [];
+
+                    let unNoProxyMatch = _.isEmpty(noProxy) || _.isUndefined(_.find(noProxy, (o) => { return minimatch(uriHost, o); }));
+
+                    if (unNoProxyMatch) {
+                        const env_proxy = String(urlParsed?.protocol == "https" ? _.get(process, "env.HTTPS_PROXY") : _.get(process, "env.HTTP_PROXY"));
+
+                        if ((_.get(option, "system_configs.proxy.envfirst") > 0 || _.isEmpty(_.get(process, "versions.electron"))) && !_.isEmpty(env_proxy) && env_proxy != "undefined") {
+                            let env_proxy_parse = new Url(env_proxy);
+                            _.set(proxy, "host", _.join(env_proxy_parse?.host, ".") || "");
+                            _.set(proxy, "port", _.toInteger(env_proxy_parse?.port) > 0 ? _.toInteger(env_proxy_parse?.port) : 0);
+                        } else if (!_.isEmpty(_.get(process, "versions.electron"))) {
+                            try {
+                                const electronProxy = await require("electron").session.defaultSession.resolveProxy(url);
+                                const match = electronProxy.match(/PROXY (([^:]+):(\d+))/);
+
+                                if (_.isObject(match) && _.isString(match[2]) && !_.isEmpty(match[2]) && _.toInteger(match[3]) > 0
+                                ) {
+                                    _.set(proxy, "host", match[2]);
+                                    _.set(proxy, "port", _.toInteger(match[3]));
+                                }
+                            } catch (e) { }
+                        }
+                    }
+                }
+
+                if (_.isString(proxy.host) && proxy.host != "") {
+                    _.set(proxy, "tunnel", _.toLower(urlParsed?.protocol) == "http" ? false : true);
+                    _.set(proxy, "authenticate", _.get(option, "system_configs.proxy.auth.authenticate") > 0 ? true : false);
+
+                    if (proxy.authenticate) {
+                        _.set(proxy, "username", _.get(option, "system_configs.proxy.auth.username"));
+                        _.set(proxy, "password", _.get(option, "system_configs.proxy.auth.password"));
+                    }
+                }
+
+                if (!_.isEmpty(proxy) && _.isString(proxy.host) && proxy.host != "" && proxy.host != "undefined") {
+                    return callback(null, proxy)
+                } else {
+                    return callback(null, null)
+                }
+            } catch (e) {
+                return callback(null, null)
+            }
+        }
+    };
+
+    // 证书
+    if (!_.isEmpty(certificates)) {
+        _.assign(options, {
+            certificates: new sdk.CertificateList(
+                {},
+                certificates
+            )
+        })
+    }
+
+    return options;
+}
+
+// 转 postman 事件
+const convert2PostmanEvent = (request, listen, option) => {
+    const { requestJson } = request;
+    const { database_configs, env, dynamic_option, custom_functions } = option;
+
+    let customFuncScript = '';
+    _.forEach(custom_functions, (script, name) => {
+        name = _.trim(name);
+        if (name != '') {
+            customFuncScript = `
+            ${customFuncScript}
+
+            function ${name}(text) {
+                try{
+                    ${script}
+                }catch(e){
+                    return text;
+                }
+            }
+            `;
+        }
+    })
+
+    const sysScript = [
+        // "(async function(){",
+        "const response = {};",
+        `
+        const splitCookieString = (input)=> {
+            let index = input.indexOf('=');
+            if (index === -1) {
+                return [input];
+            }
+            return [input.slice(0, index), input.slice(index + 1)];
+        }
+        `,
+
+        `
+        const getMainProcessSocketPath = ()=>{
+            return "${_.get(process, 'env.main_process_socket_path')}"
+        }
+        `,
+
+        "let lodashv4 = require('lodash');",
+        "let { mockExp } = require('exp-mock');",
+        "let Mock = require('mockjs');",
+        "let xml2json = xml2Json;",
+        "let JSON5 = require('json5');",
+        "let aTools = require('apipost-tools');",
+        "let jsonpath = require('jsonpath');",
+        `let _envTmpVariablesData = ${JSON.stringify(env)}`,
+        `let _dynamicValueOptions = ${JSON.stringify(dynamic_option)}`,
+        "let $ = {}; $.md5 = function(str){return CryptoJS.MD5(str).toString()};$.ajax = pm.ajaxSendRequest;",
+        `pm.environment.getPreUrl = function(){return _.get(_envTmpVariablesData, "env_pre_url");}`,
+        `pm.environment.getName = function(){return _.get(_envTmpVariablesData, "env_name");}`,
+        "pm.environment.getCollection = function(){return pm.environment.toObject();}",
+        `pm.variables.getPreUrl = function(){return _.get(_envTmpVariablesData, "env_pre_url");}`,
+        `pm.variables.getName = function(){return _.get(_envTmpVariablesData, "env_name");}`,
+        "pm.variables.getCollection = function(){return pm.environment.toObject();}",
+        "pm.environment.delete = pm.environment.unset;",
+        "pm.variables.delete = pm.variables.unset;",
+        "pm.globals.delete = pm.globals.unset;",
+        "pm.Visualizing = pm.visualizer.set", // 兼容旧版本的可视化
+        `
+        // Database
+        pm.queryDatabase = async (dbconfig) => {
+            const { query } = dbconfig;
+            const { createUnixClient } = require('net'),
+                socketPath = getMainProcessSocketPath();
+
+            try{
+                const result = await createUnixClient(socketPath, JSON.stringify({
+                    action: 'queryDatabase',
+                    data: { dbconfig, query }
+                }));
+                
+                return JSON.parse(Buffer.from(JSON.parse(result.toString())).toString());
+            }catch(e){
+                return { err: 'error', result:String(e)}
+            }
+        };
+
+        // pm.execute
+        pm.execute = async (file, args, option) => {
+            const { createUnixClient } = require('net'),
+                socketPath = getMainProcessSocketPath();
+
+            try {
+                const result = await createUnixClient(socketPath, JSON.stringify({
+                    action: 'execute',
+                    data: { file, args, option }
+                }));
+
+                const resultObj = JSON.parse(Buffer.from(JSON.parse(result.toString())).toString());
+
+                if(resultObj?.err == 'success'){
+                    return resultObj?.result
+                }else{
+                    throw new Error(resultObj?.result);
+                }
+            }
+            catch (e) {
+                throw new Error(e);
+            }
+        };
+        `,
+        `
+        let _requestTmpBodyObject = request?.data
+        try{
+            _requestTmpBodyObject = JSON.stringify(JSON5.parse(request?.data));
+        }catch(e){}
+        
+        try{
+            let _requestTmpVariablesData = ${JSON.stringify({ name: requestJson?.name })}
+            _.assign(request, {
+                    request_headers: pm.request?.headers?.toObject(), 
+                    request_bodys: _requestTmpBodyObject, 
+                    request_querys: pm.request?.url?.query?.toObject(),
+                    request_variables: pm.request?.url?.variables?.toObject(),
+                    mode: "${_.get(requestJson, "request.body.mode")}",
+                    contentType: pm.request?.headers?.get('content-type'),
+                    id: "${requestJson?.sample_id || requestJson?.target_id}",
+                    name: _.get(_requestTmpVariablesData, "name") || "HTTP request",
+                    url: String(pm.request?.url),
+                    uri: pm.request?.url
+            });
+        }catch(e){}
+
+        // 获取最终请求body
+        try{
+            pm.getFinalRequestRawBody = () => {
+                let requestBody = pm.variables.replaceIn(request.request_bodys);
+
+                if(lodashv4.isString(requestBody)){
+                    const regex = /{{([^}]+)}}/g;
+                    const matches = requestBody.match(regex);
+                    if (!lodashv4.isEmpty(matches)) {
+                        lodashv4.forEach(matches, (match) => {
+                            try {
+                                const tmpVal = mockExp(match, _dynamicValueOptions?.all_vars || {}, _dynamicValueOptions?.lang || 'en', _dynamicValueOptions?.custom_functions || {});
+
+                                if (tmpVal != match && !lodashv4.isUndefined(tmpVal)) {
+                                    requestBody = lodashv4.replace(requestBody, match, tmpVal);
+                                }
+                            } catch (e) { }
+                        })
+                    }
+
+                    pm.setRequestBody(requestBody);
+                }
+                
+                return requestBody;
+            }
+        }catch(e){
+            pm.getFinalRequestRawBody = () => {}
+        }
+
+        // 变量替换（含动态值）
+        try{
+            pm.mock = (str) => {
+                if(lodashv4.isString(str)){
+                    const regex = /{{([^}]+)}}/g;
+                    const matches = str.match(regex);
+                    if (!lodashv4.isEmpty(matches)) {
+                        lodashv4.forEach(matches, (match) => {
+                            try {
+                                const tmpVal = mockExp(match, _dynamicValueOptions?.all_vars || {}, _dynamicValueOptions?.lang || 'en', _dynamicValueOptions?.custom_functions || {});
+
+                                if (tmpVal != match && !lodashv4.isUndefined(tmpVal)) {
+                                    str = lodashv4.replace(str, match, tmpVal);
+                                }
+                            } catch (e) { }
+                        })
+                    }
+
+                }
+                return str;
+            }
+        }catch(e){
+            pm.mock = (str) => {return str}
+        }
+        `,
+        "if(_.isObject(pm.response)){",
+        "try{",
+        "_.set(response, 'headers', pm.response.headers?.toObject());",
+        "}catch(e){}",
+        `try{ // 设置cookie
+            response.cookies = {};
+            const responseCookies = lodashv4.get(pm.response.headers.toObject(), 'set-cookie');
+            lodashv4.forEach(lodashv4.isArray(responseCookies)?responseCookies:[responseCookies], (cookieStr) => {
+                let cookieArr = splitCookieString(lodashv4.head(lodashv4.split(cookieStr, ';')));
+                let cookieValue = lodashv4.join(lodashv4.tail(cookieArr),'');
+
+                if(cookieArr[0] && cookieValue){
+                    try{
+                        _.set(response.cookies, cookieArr[0], decodeURIComponent(cookieValue))
+                    }catch(e){
+                        _.set(response.cookies, cookieArr[0], cookieValue)
+                    }
+                }
+            })
+        }catch(e){}
+        `,
+        "_.set(pm, 'response.raw.responseText', pm.response.text());",
+        "_.set(response, 'raw.responseText', pm.response.text());",
+        "try{",
+        "_.set(response, 'json', pm.response.json());",
+        "_.set(response, 'raw.json', pm.response.json());",
+        "}catch(e){_.set(response, 'raw.json', {})}",
+        "_.set(response, 'raw.status', pm.response.code);",
+        "_.set(response, 'raw.responseTime', pm.response.responseTime);",
+        "    pm.response.setBody = function (body) {",
+        "        if (typeof body !== 'string') {",
+        "            body = JSON.stringify(body);",
+        "        }",
+        "        if (typeof body === 'string') {",
+        "            const originalText = _.cloneDeep(pm.response.text());",
+        "            try {",
+        "               const originalJson = _.cloneDeep(pm.response.json());",
+        "               pm.response.originalJson = function () {",
+        "                   return originalJson;",
+        "               };",
+        "            }",
+        "            catch (e) {",
+        "                pm.response.originalJson = function () {",
+        "                    return null;",
+        "                };",
+        "            }",
+        "            pm.response.originalText = function () {",
+        "                return originalText;",
+        "            };",
+        "            pm.response.stream = Buffer.from(body);",
+        `            pm.variables.set("_pm.response.setBody", body);`,
+        "        }",
+        "    };",
+        "",
+        "    pm.response.setCode = function (code) {",
+        "        if (typeof code === 'number') {",
+        "            pm.response.originalCode = function () {",
+        "                return pm.response.code;",
+        "            };",
+        "",
+        "            pm.response.code = code;",
+        `            pm.variables.set("_pm.response.code", code);`,
+        "        }",
+        "    };",
+        "}",
+        "const apipost = postman;",
+        "const apt = fox = ea = echoapi = insomnia = pm;", // TODO 兼容旧版本apipost的语法、增加更多三方库
+        `
+        // Compatible with tc
+        const expect = pm.expect;
+        const assert = pm.assert;
+        assert.equal = (source, dist) => { return source === dist }
+        const tc = {};
+        try {
+            // global
+            tc.loadModule = require;
+            tc.info = {};
+            tc.delay = sleep;
+
+            // Ignored library
+            tc.exec = () => { console.warn("The tc.exec script syntax of Thunder client is not supported.") }
+            tc.runRequest = () => { console.warn("The tc.runRequest script syntax of Thunder client is not supported, Please use pm.sendRequest() instead.") }
+            tc.skipRequest = () => { console.warn("The tc.skipRequest script syntax of Thunder client is not supported.") }
+            tc.chartHTML = () => { console.warn("The tc.chartHTML script syntax of Thunder client is not supported.") }
+            tc.retryRequest = () => { console.warn("The tc.retryRequest script syntax of Thunder client is not supported.") }
+            tc.runRequest = () => { console.warn("The tc.runRequest script syntax of Thunder client is not supported.") }
+            tc.setCookie = () => { console.warn("The tc.setCookie script syntax of Thunder client is not supported.") }
+            tc.clearCookies = () => { console.warn("The tc.clearCookies script syntax of Thunder client is not supported.") }
+            tc.getCookies = () => { console.warn("The tc.getCookies script syntax of Thunder client is not supported.") }
+            tc.readFile = () => { console.warn("The tc.readFile script syntax of Thunder client is not supported.") }
+            tc.loadFromPath = () => { console.warn("The tc.loadFromPath script syntax of Thunder client is not supported.") }
+
+            // test
+            tc.test = (name, func) => {
+                if (lodashv4.isFunction(func)) {
+                    if(!lodashv4.isUndefined(func())){
+                        try{
+                            pm.test(name, func)
+                        }catch(e){}
+                    }else{
+                        pm.test(name, pm.expect(func()).to.equal(true))
+                    }
+                } else {
+                    pm.test(name, pm.expect(lodashv4.toInteger(func) > 0 ? true : false).to.equal(true))
+                }
+            }
+
+            // var
+            tc.setVar = (key, value) => { pm.environment.set(key, value) };
+            tc.getVar = (key) => { return pm.environment.get(key) };
+
+            // Param
+            tc.setParam = (key, value) => { pm.setRequestQuery(key, value) };
+
+            // request
+            tc.request = lodashv4.cloneDeep(request);
+            tc.request.body = {};
+            tc.request.name = request.name;
+            tc.request.id = request.id;
+            tc.request.name = request.name;
+            tc.request.setHeader = (key, value) => { pm.setRequestHeader(key, value) };
+            tc.request.getHeader = (key) => { return pm.request.headers.get(key) };
+            tc.request.setBody = (key, value) => { pm.setRequestBody(key, value) };
+
+            // response
+            if (lodashv4.isObject(pm.response)) {
+                tc.response = lodashv4.cloneDeep(response);
+                tc.response.size = pm.response.responseSize;
+                tc.response.status = pm.response.code;
+                tc.response.time = pm.response.responseTime;
+                tc.response.text = response?.raw?.responseText;
+                tc.response.contentType = lodashv4.get(response, 'headers.content-type');
+                tc.response.cookies = lodashv4.toPairs(lodashv4.get(tc, 'response.cookies')).map(([key, value]) => ({ key, value }));
+                tc.response.headers = lodashv4.cloneDeep(lodashv4.cloneDeep(pm.response.headers.toJSON()));
+                tc.response.getHeader = (key) => { return lodashv4.get(response.headers, lodashv4.toLower(key)) };
+                tc.response.getBinary = () => { console.warn("The tc.getBinary script syntax of Thunder client is not supported.") }
+            }
+        } catch (e) {
+            console.warn("Thunder Client script has an issue; please check manually. EchoAPI is fully compatible with Postman.")
+        }
+            
+        // 自定义函数
+        ${customFuncScript}
+        `, // 兼容 thuner client 
+    ];
+
+    const pmEvent = {
+        prerequest: [],
+        test: [],
+    };
+    const eventMap = {
+        pre_tasks: "prerequest",
+        post_tasks: "test",
+    };
+
+    _.forEach(_.keys(eventMap), (type) => {
+        let exec = _.join(sysScript, "\n");
+        _.forEach(_.get(requestJson, `request.${type}`), (item) => {
+            if (_.isObject(item)) {
+                if (item.enabled > 0) {
+                    switch (item.type) {
+                        case "customScript": // done
+                            if (!_.isEmpty(item?.data) && _.isString(item?.data) && item?.data != 'undefined') {
+                                exec = `${exec}\n${_.trim(item?.data)}\n`;
+                            }
+                            break;
+                        case "database": // done
+                            let dbconfig = database_configs[item.data?.connectionId] || {};
+
+                            if (!_.isEmpty(dbconfig)) {
+                                dbconfig = JSON.stringify(dbconfig, null, "\t");
+                                exec = `${exec}
+                                    ! await (async function(){ 
+                                        const dbData = ${JSON.stringify(item.data || { query: '' })}
+                                        const query = pm.variables.replaceIn(_.get(dbData, "query"));
+                                        const method = pm.variables.replaceIn(_.get(dbData, "method") || "");
+
+                                        try{
+                                            let dbResultList = await pm.queryDatabase(_.assign(${dbconfig},{
+                                                method:method,
+                                                query:query
+                                            }));
+
+                                            let {err, result} = dbResultList;
+
+                                            if(err == 'success'){
+                                                if(${item.data?.isConsoleOutput} > 0){
+                                                    console.log(query, result)
+                                                }
+                                                if(_.isObject(result)){
+                                                    _.forEach(${JSON.stringify(item.data?.variables || [])}, (item) => {
+                                                        let extra_value = jsonpath.value(result, _.trim(item?.pattern));
+                                                        pm[item?.type].set(item?.name, extra_value);
+                                                    });
+                                                }else{
+                                                    if(!_.isObject(result)){
+                                                        _.forEach(${JSON.stringify(item.data?.variables || [])}, (item) => {
+                                                            let extra_value = result;
+                                                            pm[item?.type].set(item?.name, extra_value);
+                                                        });
+                                                    }
+                                                } 
+                                            }else{
+                                                console.error(query, String(result))
+                                            }                                                                                        
+                                        }catch(e){};
+                                    })();`;
+                            }
+                            break;
+                        case "wait": // done
+                            const timeout = _.toInteger(item?.data);
+
+                            if (timeout > 0) {
+                                exec = `${exec}\nsleep(${timeout});`;
+                            }
+                            break;
+                        case "assert": //done
+                            exec = `${exec}
+                                !(function(){ 
+                                    let assertObjectData = ${JSON.stringify(item)};
+                                    let responseData = '';
+                                    let expertData = null;
+                                    let expertExpression = '';
+                                    let expertValue = null;
+
+                                    if(_.get(assertObjectData, "data.type") == 'responseJson'){
+                                        try{
+                                            responseData = pm.response.json();
+                                        }catch(e){
+                                            responseData = xml2Json(pm.response.text())
+                                        }
+
+                                        expertData = jsonpath.value(responseData, _.get(assertObjectData, "data.expression.path"));
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseXml'){
+                                        try{
+                                            responseData = pm.response.text();
+                                            var xpath = require('xpath');
+                                            var dom = require('xmldom').DOMParser;
+                                            expertData = String(xpath.select(_.get(assertObjectData, "data.expression.path"), new dom().parseFromString(responseData, 'text/xml')));
+                                        }catch(e){}
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseText'){
+                                        expertData = pm.response.text();
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseHeader'){
+                                        expertData = pm.response.headers.get(_.get(assertObjectData, "data.expression.path"));
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseCookie'){
+                                        expertData = _.get(response.cookies, _.get(assertObjectData, "data.expression.path"));
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseCode'){
+                                        expertData = pm.response.code;
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseTime'){
+                                        expertData = pm.response.responseTime;
+                                    }else if(_.get(assertObjectData, "data.type") == 'responseSize'){
+                                        expertData = pm.response.responseSize;
+                                    }else if(_.get(assertObjectData, "data.type") == 'tempVars'){
+                                        expertData = pm.variables.get(_.get(assertObjectData, "data.expression.path"));
+                                    }else if(_.get(assertObjectData, "data.type") == 'envVars'){
+                                        expertData = pm.environment.get(_.get(assertObjectData, "data.expression.path"));
+                                    }else if(_.get(assertObjectData, "data.type") == 'globalVars'){
+                                        expertData = pm.globals.get(_.get(assertObjectData, "data.expression.path"));
+                                    }
+                                    
+                                    expertValue = pm.variables.replaceIn(_.get(assertObjectData, "data.expression.compareValue"));
+                                    
+                                    if(_.get(assertObjectData, "data.expression.compareType") == "eq"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.eql(String(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "uneq"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.not.eql(String(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "lt"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(lodashv4.toNumber(expertData)).to.be.below(lodashv4.toNumber(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "lte"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(lodashv4.toNumber(expertData)).to.be.at.most(lodashv4.toNumber(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "gt"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(lodashv4.toNumber(expertData)).to.be.above(lodashv4.toNumber(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "gte"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(lodashv4.toNumber(expertData)).to.be.at.least(lodashv4.toNumber(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "includes"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.include(String(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "unincludes"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.not.include(String(expertValue));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "null"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(expertData).to.be.empty;
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "notnull"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.not.be.empty;
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "exist"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(expertData).to.exist;
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "notexist"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(expertData).to.not.exist;
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "regularmatch"){
+                                        expertExpression = null;
+
+                                        if(!lodashv4.isEmpty(expertValue)){
+                                            expertValue = new RegExp(lodashv4.trim(expertValue, '/'));
+
+                                            pm.test(_.get(assertObjectData, "name"), function () {
+                                                pm.expect(expertData).to.match(expertValue);
+                                            });
+                                        }
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "belongscollection"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.be.oneOf(lodashv4.split(expertValue, ","));
+                                        });
+                                    }else if(_.get(assertObjectData, "data.expression.compareType") == "notbelongscollection"){
+                                        expertExpression = null;
+                                        pm.test(_.get(assertObjectData, "name"), function () {
+                                            pm.expect(String(expertData)).to.not.be.oneOf(lodashv4.split(expertValue, ","));
+                                        });
+                                    }
+                                })();
+                                `;
+                            break;
+                        case "pickVars": //done
+                            const varTypeMap = {
+                                tempVars: "variables",
+                                envVars: "environment",
+                                globalVars: "globals",
+                            };
+                            exec = `${exec}\n
+                                !(function(){ 
+                                `
+                            switch (item.data?.source) {
+                                case "responseJson":
+                                    exec = `${exec}\n
+                                        let varSource = '';
+
+                                        try{
+                                            varSource = pm.response.json();
+                                        }catch(e){
+                                            varSource = xml2Json(pm.response.text())
+                                        }
+                                        `;
+                                    break;
+                                case "responseXml":
+                                case "responseText":
+                                    exec = `${exec}\n
+                                        let varSource = pm.response.text();
+                                        `;
+                                    break;
+                                case "responseHeader":
+                                    exec = `${exec}\n
+                                        let varSource = pm.response.headers;
+                                        `;
+                                    break;
+                                case "responseCookie":
+                                    exec = `${exec}\n
+                                        let varSource = response.cookies;
+                                        `;
+                                    break;
+                                case "responseCode":
+                                    exec = `${exec}\n
+                                        let varSource = pm.response.code;
+                                        `;
+                                    break;
+                                case "responseTime":
+                                    exec = `${exec}\n
+                                        let varSource = pm.response.responseTime;
+                                        `;
+                                    break;
+                                case "responseSize":
+                                    exec = `${exec}\n
+                                        let varSource = pm.response.responseSize;
+                                        `;
+                                    break;
+                            }
+
+                            _.forEach(item.data?.variables, (varItem) => {
+                                if (_.isObject(varItem) && varItem?.name != "" && !_.isUndefined(varTypeMap[varItem?.type])) {
+                                    switch (item.data?.source) {
+                                        case "responseJson":
+                                            exec = `${exec}\n
+                                                    !(function(){
+                                                        let pickVars = ${JSON.stringify(varItem)};
+                                                        pm[${JSON.stringify(varTypeMap[varItem?.type])}].set(_.get(pickVars,"name"), jsonpath.value(varSource, _.trim(_.get(pickVars,"expression"))));
+                                                    })();
+                                                    `;
+                                            break;
+                                        case "responseXml":
+                                            exec = `${exec}\n
+                                                    !(function(){
+                                                        let pickVars = ${JSON.stringify(varItem)};
+                                                        let xmlValue = '';
+                                                        var xpath = require('xpath');
+                                                        var dom = require('xmldom').DOMParser;
+
+                                                        try{
+                                                            xmlValue = String(xpath.select(_.trim(_.get(pickVars,"expression")), new dom().parseFromString(varSource, 'text/xml')));
+                                                        }catch(e){}
+
+                                                        pm[${JSON.stringify(varTypeMap[varItem?.type])}].set(_.get(pickVars, "name"), xmlValue);
+                                                    })();
+                                                    `;
+                                            break;
+                                        case "responseHeader":
+                                            exec = `${exec}\n
+                                                    !(function(){
+                                                        let pickVars = ${JSON.stringify(varItem)};
+                                                        try{
+                                                            pm[${JSON.stringify(varTypeMap[varItem?.type])}].set(_.get(pickVars,"name"), varSource.get(_.trim(_.get(pickVars,"expression"))));
+                                                        }catch(e){}
+                                                    })();
+                                                    `;
+                                            break;
+                                        case "responseCookie":
+                                            exec = `${exec}\n
+                                                    !(function(){
+                                                        let pickVars = ${JSON.stringify(varItem)};
+                                                        pm[${JSON.stringify(varTypeMap[varItem?.type])}].set(_.get(pickVars,"name"), _.get(varSource, _.trim(_.get(pickVars,"expression"))));
+                                                    })();
+                                                    `;
+                                            break;
+                                        case "responseText":
+                                        case "responseCode":
+                                        case "responseTime":
+                                        case "responseSize":
+                                            exec = `${exec}\n
+                                                    !(function(){
+                                                        let pickVars = ${JSON.stringify(varItem)};
+                                                        pm[${JSON.stringify(varTypeMap[varItem?.type])}].set(_.trim(_.get(pickVars, "name")), varSource);
+                                                    })();
+                                                    `;
+                                            break;
+                                    }
+                                }
+                            }
+                            );
+                            exec = `${exec}
+                                })();`
+                            break;
+                    }
+                }
+            }
+        }
+        );
+
+        exec = `${exec}\n
+            if(_.isObject(pm.response)){
+                if(!_.isFunction(pm.response.originalText) || pm.response.originalText() == pm.response.text()){
+                    if(response?.raw?.responseText != pm.response.text()){
+                        pm.response.setBody(response?.raw?.responseText);
+                    }else if(pm.response?.raw?.responseText != pm.response.text()){
+                        pm.response.setBody(pm.response?.raw?.responseText);
+                    }
+                }
+            }
+            `;
+        let execArr = _.split(exec, "\n");
+        // execArr.push("})()");
+        pmEvent[eventMap[type]].push({
+            listen: eventMap[type],
+            script: {
+                exec: execArr,
+                type: "text/javascript",
+            },
+        });
+    });
+
+    return pmEvent[listen];
+}
+
+// 转换pm request为输出的request
+function convert2EchoRequest(request, requestJson, postmanJSON, history) {
+    const cloneRequest = _.assign(_.cloneDeep(request), _.pick(requestJson, ['project_id', 'target_id', 'name']));
+
+    // 请求体类型
+    cloneRequest.mode = _.get(requestJson, "request.body.mode");
+
+    // 其他请求参数
+    try {
+        cloneRequest.paths = _.fromPairs((_.get(postmanJSON, "url.variable") || []).map((item) => [item.key, item.value,])) || {};
+    } catch (e) { }
+
+    try {
+        const allRequestHeaders = _.mapValues(_.keyBy(_.get(history, 'execution.data[0].request.headers') || {}, 'key'), 'value');
+
+        if (!_.isEmpty(allRequestHeaders) && _.isObject(allRequestHeaders)) {
+            cloneRequest.headers = allRequestHeaders;
+        } else {
+            cloneRequest.headers = _.reduce(cloneRequest.headers?.toJSON(), (obj, item) => {
+                obj[item.key] = item.value;
+                return obj;
+            }, {}
+            );
+        }
+    } catch (e) { }
+
+    try {
+        cloneRequest.querys = cloneRequest.url?.query?.toObject();
+        cloneRequest.url = String(cloneRequest.url);
+    } catch (e) { }
+
+    try {
+        cloneRequest.body = _.get(request, `body.${_.get(request, "body.mode")}`);
+
+        if (cloneRequest.mode == "msgpack") {
+            const msgpack = require("msgpack5")();
+            try {
+                cloneRequest.body = JSON.stringify(msgpack.decode(Buffer.from(_.values(cloneRequest.body))));
+            } catch (e) { }
+        }
+
+        try {
+            cloneRequest.body = cloneRequest.body.toObject();
+        } catch (e) { }
+    } catch (e) { }
+
+    try {
+        cloneRequest.uri = request?.url.toJSON();
+        _.forEach(cloneRequest.uri, (value, key) => {
+            if (key == "query") {
+                cloneRequest.uri[key] = value.toObject();
+            } else if (key == "host") {
+                cloneRequest.uri[key] = _.join(value, ".");
+            } else if (key == "path") {
+                cloneRequest.uri[key] = _.join(value, "/");
+            } else {
+                if (_.isArray(value)) {
+                    cloneRequest.uri[key] = _.join(value, "");
+                }
+            }
+        });
+    } catch (e) { }
+
+    // 获取cookies
+    cloneRequest.cookies = {};
+
+    try {
+        const cookiesString = cloneRequest.headers?.cookie;
+        if (!_.isEmpty(cookiesString) && _.isString(cookiesString)) {
+            _.forEach(_.split(cookiesString, ";"), (cookie) => {
+                const { key, value } = tough.Cookie.parse(cookie).toJSON();
+                cloneRequest.cookies[key] = value;
+            });
+        }
+    } catch (e) { }
+
+    return cloneRequest;
+}
+
+// 转换pm response为输出的response
+async function convert2EchoResponse(response, history) {
+    const cloneResponse = _.cloneDeep(response);
+    _.unset(cloneResponse, "_details");
+
+    // 响应体
+    try {
+        _.assign(cloneResponse, {
+            body: String(cloneResponse.stream),
+        });
+    } catch (e) { }
+
+    // 判断适合什么格式输出
+    try {
+        let fitForShow = "Monaco";
+        let mimeType = {
+            ext: "json",
+            mime: "application/json",
+        };
+
+        if (isSvg(cloneResponse.body)) {
+            _.assign(mimeType, {
+                ext: "svg",
+                mime: "image/svg+xml",
+            });
+            fitForShow = "Image";
+        } else {
+            const fileType = await FileType.fromBuffer(cloneResponse.stream);
+
+            if (_.isObject(fileType)) {
+                _.assign(mimeType, fileType);
+                if (isImage(`test.${mimeType?.ext}`)) {
+                    fitForShow = "Image";
+                } else if (mimeType?.ext == "pdf") {
+                    fitForShow = "Pdf";
+                } else if (mimeType?.ext == "xml") {
+                    fitForShow = "Monaco";
+                } else {
+                    fitForShow = "Other";
+                }
+            } else {
+                const contentType = getCaseInsensitive(cloneResponse?.headers || {}, "content-type") || "";
+                if (!_.isEmpty(contentType)) {
+                    mimeType = {
+                        ext: mime.getExtension(contentType),
+                        mime: mime.getType(mime.getExtension(contentType)),
+                    };
+                } else {
+                    const ext = aTools.isJson(cloneResponse.body) ? "json" : aTools.isJsonp(cloneResponse.body) ? "jsonp" : "html";
+                    mimeType = {
+                        ext: ext,
+                        mime: mime.getType(ext) || "application/jsonp",
+                    };
+                }
+            }
+        }
+
+        _.assign(cloneResponse, { mimeType, fitForShow });
+    } catch (e) { }
+
+    // 响应头对象
+    const responseHeader = {};
+    try {
+        _.assign(
+            responseHeader,
+            _.reduce(
+                response.headers?.toJSON(),
+                (obj, item) => {
+                    if (obj[item.key]) {
+                        if (!Array.isArray(obj[item.key])) {
+                            obj[item.key] = [obj[item.key]];
+                        }
+                        obj[item.key].push(item.value);
+                    } else {
+                        obj[item.key] = item.value;
+                    }
+                    return obj;
+                },
+                {}
+            )
+        );
+    } catch (e) { }
+
+    // 响应头
+    try {
+        _.assign(cloneResponse, {
+            headers: responseHeader,
+        });
+    } catch (e) { }
+
+    // 缓存文件名
+    let cacheFileName = `${cloneResponse?.id}.${cloneResponse?.mimeType?.ext}`;
+    try {
+        cacheFileName = _.get(contentDisposition.parse(getCaseInsensitive(responseHeader || {}, "content-disposition")), "parameters.filename");
+
+        if (_.isString(cacheFileName)) {
+            try {
+                cacheFileName = decodeURIComponent(cacheFileName);
+            } catch (e) { }
+        }
+    } catch (e) { }
+
+    cloneResponse.filename = cacheFileName;
+
+    // cookie
+    cloneResponse.cookies = {};
+    cloneResponse.arrCookies = [];
+
+    let cookieArrs = getCaseInsensitive(responseHeader || {}, "set-cookie");
+    if (_.isString(cookieArrs)) {
+        cookieArrs = [cookieArrs];
+    }
+
+    try {
+        _.forEach(cookieArrs, (cookie) => {
+            const cookieJson = tough.Cookie.parse(cookie).toJSON();
+            _.assign(cookieJson, {
+                name: cookieJson?.key,
+                cookie_id: aTools.snowflakeId(`cookie_id_${uuidv4()}`),
+            });
+            cloneResponse.arrCookies.push(cookieJson);
+            const { key, value } = cookieJson;
+            cloneResponse.cookies[key] = value;
+        });
+    } catch (e) { }
+
+    const requestStart =
+        _.get(history, "execution.data.0.timings.requestStart") || Date.now();
+    _.assign(cloneResponse, {
+        proxy: _.get(history, "execution.data.0.request.proxy") || {},
+        timings: _.mapKeys(
+            _.get(history, "execution.data.0.timings.offset") || {},
+            (value, key) => _.snakeCase(key)
+        ),
+        requestStart,
+        response_at: requestStart,
+    });
+
+    return cloneResponse;
+}
+
+const preProcessMockExp = (request, requestPara, AllVars, option) => {
+    const { postmanJSON } = requestPara;
+    const { lang, customFunctions } = option;
+
+    // 识别变量
+    const regex = /{{([^}]+)}}/g;
+
+    // 替换 URL 中可能的变量
+    let url = String(request?.url || '');
+    if (!_.isEmpty(url)) {
+        const matches = url.match(regex);
+        if (!_.isEmpty(matches)) {
+            _.forEach(matches, (match) => {
+                try {
+                    const tmpVal = mockExp(match, AllVars, lang, customFunctions);
+
+                    if (tmpVal != match && !_.isUndefined(tmpVal)) {
+                        url = _.replace(url, match, tmpVal);
+                    }
+                } catch (e) { }
+            })
+
+            _.set(request, 'url', new sdk.Url(url));
+        }
+    }
+
+    // 重置 restful
+    _.forEach(_.get(postmanJSON, 'url.path'), (item, key) => { //variable
+        // console.log(item)
+        if (_.startsWith(item, ":")) {
+            const pathVarKey = _.findKey(_.get(postmanJSON, 'url.variable'), (vars) => {
+                return vars?.key == _.trimStart(item, ':')
+            });
+
+            if (_.startsWith(_.get(postmanJSON, `url.variable.${pathVarKey}.value`), '{{') && _.endsWith(_.get(postmanJSON, `url.variable.${pathVarKey}.value`), '}}') && !_.isUndefined(_.get(request, `url.path.${key}`))) {
+                _.set(postmanJSON, `url.variable.${pathVarKey}.value`, _.get(request, `url.path.${key}`));
+            }
+        }
+    })
+
+    // 替换 Header 中可能的变量
+    if (!_.isEmpty(request.headers)) {
+        request?.headers?.each((item) => {
+            if (!item?.disabled) {
+                ['key', 'value'].forEach((type) => {
+                    let currentPara = String(_.get(item, type));
+                    const matches = currentPara.match(regex);
+                    if (!_.isEmpty(matches)) {
+                        _.forEach(matches, (match) => {
+                            try {
+                                const tmpVal = mockExp(match, AllVars, lang, customFunctions);
+                                if (tmpVal != match && !_.isUndefined(tmpVal)) {
+                                    currentPara = _.replace(currentPara, match, tmpVal);
+
+                                }
+                            } catch (e) { }
+                        })
+
+                        _.set(item, type, currentPara)
+                    }
+                })
+            }
+        })
+    }
+
+    // 替换 body 中可能的变量
+    const bodyMode = _.get(request, 'body.mode');
+    switch (bodyMode) {
+        case 'urlencoded':
+        case 'formdata':
+            if (!_.isEmpty(request?.body[bodyMode])) {
+                request?.body[bodyMode].each((item, key) => {
+                    if (!item?.disabled) {
+                        ['key', 'value'].forEach((type) => {
+                            let currentPara = _.get(item, type);
+                            if (_.isString(currentPara)) {
+                                const matches = currentPara.match(regex);
+
+                                if (!_.isEmpty(matches)) {
+                                    _.forEach(matches, (match) => {
+                                        try {
+                                            const tmpVal = mockExp(match, AllVars, lang, customFunctions);
+                                            if (tmpVal != match && !_.isUndefined(tmpVal)) {
+                                                currentPara = _.replace(currentPara, match, tmpVal);
+                                            }
+                                        } catch (e) { }
+                                    })
+
+                                    _.set(item, type, currentPara);
+                                }
+                            }
+                        })
+                    }
+                })
+            }
+            break;
+        default:
+            let rawBody = _.get(request, 'body.raw');
+            if (_.isString(rawBody) && !_.isEmpty(rawBody)) {
+                const matches = rawBody.match(regex);
+                if (!_.isEmpty(matches)) {
+                    _.forEach(matches, (match) => {
+                        try {
+                            const tmpVal = mockExp(match, AllVars, lang, customFunctions);
+                            if (tmpVal != match && !_.isUndefined(tmpVal)) {
+                                rawBody = _.replace(rawBody, match, tmpVal);
+                            }
+                        } catch (e) { }
+                    })
+
+                    _.set(request, 'body.raw', rawBody);
+                }
+            }
+            break;
+    }
+
+    return request;
+}
+
+// 初始化api请求参数
+const initRequestJson = (event, option) => {
+    // 获取具体的请求详情
+    const requestJson = _.assign(_.pick(event, ['event_id', 'test_id']), _.pick(event?.data, ['target_id', 'project_id']));
+
+    if (_.includes(['api', 'sample', 'sse', 'request'], event?.type)) {
+        // 原接口信息
+        if (_.toInteger(event?.auto_sync) > 0 || _.includes(['http_request', 'get_parsed_request'], option?.scene)) {
+            _.assign(requestJson, getAPIFromCollection(option?.collection, _.get(event, `data.target_id`)));
+        } else { // 从 data的 apiData 获取
+            _.assign(requestJson, _.get(event, `data.apiData`));
+        }
+
+        // 向上查询获取最终参数
+        const parentIDs = [];
+
+        // 为向上查询获取最终参数做准备，获取正确的 parent_id
+        if (_.includes(['sample'], event?.type)) {
+            const sampleTargetID = _.get(getAPIFromCollection(option?.collection, _.get(event, `data.parent_id`)), 'target_id');
+
+            if (_.isString(sampleTargetID) && sampleTargetID) {
+                getParentTargetIDs(option?.collection, requestJson?.sampleTargetID, parentIDs);
+            }
+        }
+
+        if (!_.includes(parentIDs, "0")) {
+            parentIDs.push("0");
+        }
+
+        // 设置 ["header", "body", "query", "cookie"]
+        _.forEach(parentIDs, (parent_id) => {
+            const request = {};
+            if (parent_id == "0") {
+                _.assign(request, _.get(option, "project.request"));
+            } else {
+                // 目录参数
+                _.assign(request, _.get(getAPIFromCollection(option?.collection, parent_id), "request"));
+            }
+
+            if (_.isObject(request) && !_.isEmpty(request)) {
+                ["header", "body", "query", "cookie"].forEach((parameter) => {
+                    let arrPara = _.filter(_.get(request, `${parameter}.parameter`), (item) => { return _.toInteger(item.is_system) > 0 || item.is_checked > 0 });
+
+                    if (!_.isEmpty(arrPara) && _.isArray(arrPara)) {
+                        const filterOrginParaArr = _.filter(_.get(requestJson, `request.${parameter}.parameter`), item => item.is_checked > 0) || []
+                        const orginPara = _.chain(filterOrginParaArr)
+                            .groupBy('key')
+                            .map((group) => _.reduce(group, (acc, item) => item.is_checked > 0 ? item : acc, group[group.length - 1]))
+                            .value();
+
+                        const mergePara = _.chain(arrPara)
+                            .groupBy('key')
+                            .map((group) => _.reduce(group, (acc, item) => item.is_checked > 0 ? item : acc, group[group.length - 1]))
+                            .value();
+
+                        if (parameter == 'header') {
+                            _.set(
+                                requestJson,
+                                `request.${parameter}.parameter`,
+                                _.unionBy(
+                                    orginPara,
+                                    mergePara,
+                                    (value) => {
+                                        return _.toLower(value['key']);
+                                    }
+                                )
+                            );
+                        } else {
+                            _.set(
+                                requestJson,
+                                `request.${parameter}.parameter`,
+                                _.unionBy(
+                                    orginPara,
+                                    mergePara,
+                                    "key"
+                                )
+                            );
+                        }
+                    }
+                })
+            }
+        });
+
+        // 设置 ['auth,pre_script,test,pre_tasks,post_tasks']
+        let commPara = {}, envServerID = _.get(requestJson, 'server_id');
+        _.forEach(_.reverse(parentIDs), (parent_id) => {
+            const request = {};
+            if (parent_id == "0") {
+                // 全局参数
+                _.assign(request, _.get(option, "project.request"));
+            } else {
+                // 目录参数
+                const parentEnvServerID = _.get(getAPIFromCollection(option?.collection, parent_id), "server_id");
+                if (_.isUndefined(envServerID) && !_.isString(parentEnvServerID)) {
+                    envServerID = parentEnvServerID;
+                }
+
+                _.assign(request, _.get(getAPIFromCollection(option?.collection, parent_id), "request"));
+            }
+
+            if (_.isObject(request) && !_.isEmpty(request)) {
+                ["auth", "pre_script", "test", "pre_tasks", "post_tasks",].forEach((parameter) => {
+                    const tmpPara = _.get(request, `${parameter}`);
+
+                    if (!_.isEmpty(tmpPara)) {
+                        if (_.isArray(tmpPara)) {
+                            commPara[parameter] = _.union(commPara[parameter], tmpPara);
+                        } else if (_.isObject(tmpPara)) {
+                            if (parameter == "auth" && _.get(tmpPara, "type") != "inherit") {
+                                _.set(commPara, "auth.type", _.get(tmpPara, "type"));
+                                _.set(commPara, `auth.${_.get(tmpPara, "type")}`, _.get(tmpPara, `${_.get(tmpPara, "type")}`));
+                            }
+                        } else if (_.isString(tmpPara)) {
+                            commPara[parameter] = `${commPara[parameter]}\n${tmpPara}`;
+                        }
+                    }
+                });
+            }
+        });
+
+        _.forEach(commPara, (paras, key) => {
+            if (!_.isEmpty(paras)) {
+                if (_.isArray(paras)) {
+                    _.set(requestJson, `request.${key}`, _.union(paras, _.get(requestJson, `request.${key}`)));
+                } else if (_.isObject(paras)) {
+                    if (key == "auth" && _.get(requestJson, "request.auth.type") == "inherit") {
+                        _.set(requestJson, "request.auth.type", _.get(paras, "type"));
+                        _.set(requestJson, `request.auth.${_.get(paras, "type")}`, _.get(paras, `${_.get(paras, "type")}`));
+                    }
+                } else if (_.isString(paras)) {
+                    _.set(requestJson, `request.${key}`, `${paras}\n${_.get(requestJson, `request.${key}`)}`);
+                }
+            }
+        });
+
+        _.unset(commPara);
+
+        // 处理 cookie 控制器传来的cookie，并将其他cookie参数一并转为 cookieArr 数组
+        const cookieArr = [];
+        if (_.get(option, "cookies.switch") > 0 && _.isArray(_.get(option, "cookies.data"))) {
+            // 先处理管理器的cookie
+            _.forEach(_.get(option, "cookies.data"), (item) => {
+                let key = _.trim(item?.key);
+                if (_.isObject(item) && !_.isEmpty(key)) {
+                    let currentKey = _.find(cookieArr, _.matchesProperty("key", key));
+
+                    // Fixed an issue where cookies do not take effect when domain input is irregular
+                    let cookieDomain = item?.domain;
+                    try {
+                        const domainParse = new Url(item?.domain);
+                        cookieDomain = _.join(domainParse?.host, '.')
+                    } catch (e) { }
+
+
+                    const currentCookie = {
+                        key: key,
+                        value: item?.value,
+                        domain: cookieDomain,
+                        path: (item?.path != 'undefined' ? item?.path : '/') || "/",
+                        expires: item?.expires || new Date(new Date().getTime() + 3600 * 1000),
+                        maxAge: item?.maxAge || 3600,
+                        secure: !!_.toInteger(item?.secure),
+                        httpOnly: !!_.toInteger(item?.httpOnly),
+                        sameSite: item?.sameSite || "strict",
+                    };
+
+                    if (currentKey > -1) {
+                        cookieArr[currentKey] = currentCookie;
+                    } else {
+                        cookieArr.push(currentCookie);
+                    }
+                }
+            }
+            );
+        }
+
+        if (_.isArray(_.get(requestJson, "request.cookie.parameter"))) {
+            //  处理接口中的cookie
+            _.forEach(_.get(requestJson, "request.cookie.parameter"), (item) => {
+                let key = _.trim(item?.key);
+                if (_.isObject(item) && !_.isEmpty(key) && item?.is_checked > 0) {
+                    let currentKey = _.find(cookieArr, _.matchesProperty("key", key));
+                    let currentCookie = {
+                        key: key,
+                        value: item?.value,
+                    };
+                    if (currentKey > -1) {
+                        cookieArr[currentKey] = currentCookie;
+                    } else {
+                        cookieArr.push(currentCookie);
+                    }
+                }
+            }
+            );
+        }
+
+        _.set(requestJson, "request.cookie.parameter", cookieArr);
+        _.unset(cookieArr);
+
+        // 前置URL
+        if (!_.isString(envServerID)) {
+            envServerID = "1";
+        }
+
+        const requestUrl = _.isString(_.get(requestJson, 'url')) ? _.get(requestJson, 'url') : _.get(requestJson, 'request.url');
+        const { globals, env } = option;
+
+        if (_.get(option, "env.env_id") == "2") {
+            let requestUrlVarReplace = requestUrl;
+
+            try {
+                _.forEach(_.assign({}, globals, _.get(env, 'environment')), (value, key) => {
+                    requestUrlVarReplace = replace2RegExp(requestUrlVarReplace, `{{${key}}}`, String(value))
+                })
+                requestUrlVarReplace = new Url(requestUrlVarReplace)
+                _.unset(requestUrlVarReplace, 'host')
+            } catch (e) { }
+
+            let mockID = requestJson?.target_id;
+
+            if (requestJson?.type == 'sample') {
+                mockID = _.get(getAPIFromCollection(option?.collection, _.get(event, `data.parent_id`)), 'target_id') || mockID;
+            }
+
+
+            if (process && process?.IS_ECHOAPI) {
+                requestUrlVarReplace.query.add({
+                    key: "echoapi_id",
+                    value: mockID
+                });
+                _.set(requestJson, "url", smartUrlJoin(`https://mock.echoapi.com/mock/${_.get(event, 'data.project_id')}/`, `${String(requestUrlVarReplace)}`));
+            } else {
+                requestUrlVarReplace.query.add({
+                    key: "apipost_id",
+                    value: mockID
+                });
+
+                _.set(requestJson, "url", smartUrlJoin(`https://mock.apipost.net/mock/${_.get(event, 'data.project_id')}/`, `${String(requestUrlVarReplace)}`));
+            }
+        } else {
+            const envPreUrl = _.trim(_.get(_.find(_.get(option, `env.env_pre_urls`), (server) => {
+                return server?.server_id == envServerID;
+            }), 'uri'));
+
+            if (envPreUrl != '') {
+                if (!_.startsWith(envPreUrl, '{{') && !_.startsWith(_.toLower(envPreUrl), 'http://') && !_.startsWith(_.toLower(envPreUrl), 'https://')) {
+                    _.set(requestJson, "url", smartUrlJoin('http://', envPreUrl, requestUrl));
+                } else {
+                    _.set(requestJson, "url", smartUrlJoin(envPreUrl, requestUrl));
+                }
+            }
+        }
+
+        // 设置 initVarReplacedUrl
+        let initVarReplacedUrl = requestJson?.url;
+        _.forEach(_.assign({}, globals, _.get(env, 'environment')), (value, key) => {
+            initVarReplacedUrl = replace2RegExp(initVarReplacedUrl, `{{${key}}}`, String(value))
+        })
+
+        _.set(requestJson, "initVarReplacedUrl", initVarReplacedUrl);
+    } else if (_.includes(['script', 'assert'], event?.type)) { // 脚本、断言 todo... 断言需要做成可视化的
+        _.set(requestJson, "request.pre_tasks", [
+            {
+                type: "customScript",
+                enabled: 1,
+                data: event?.data?.content,
+            },
+        ]);
+    } else if (_.includes(['sql'], event?.type)) { // 数据库
+        _.set(requestJson, "request.pre_tasks", [
+            {
+                "type": "database",
+                "id": event?.event_id,
+                "name": "Database",
+                "enabled": 1,
+                "data": _.assign({
+                    "connectionId": "",
+                    "query": "",
+                    "isConsoleOutput": -1,
+                    "variables": []
+                }, event?.data)
+            }
+        ])
+    } else if (_.includes(['assert_visual'], event?.type)) {
+        const { type, expression } = event?.data || {};
+
+        if (_.isString(type) && !_.isEmpty(expression)) {
+            _.set(requestJson, "request.pre_tasks", [
+                {
+                    "type": "assert",
+                    "id": event?.event_id,
+                    "name": "Visual assertion",
+                    "enabled": 1,
+                    "data": {
+                        type,
+                        "expression": _.assign({
+                            "compareType": "eq",
+                            "compareValue": "",
+                            "path": ""
+                        }, expression)
+                    }
+                }
+            ])
+        }
+    }
+
+    const postmanJSON = convert2PostmanRequest(requestJson, option);
+    return { requestJson, postmanJSON };
+}
+
+// module exports
+module.exports = (event, option, callback, eventRuntimeData, eventResultList) => {
+    const { scene } = option;
+    return new Promise((resolve) => {
+        try {
+            const { requestJson, postmanJSON } = initRequestJson(event, option)
+            const collection = new sdk.Item({
+                name: _.get(requestJson, "name") || "New request", request: postmanJSON, event: [], protocolProfileBehavior: {
+                    disableBodyPruning: true,
+                    disabledSystemHeaders: {
+                        'accept': true,
+                        'accept-encoding': true,
+                        'connection': true
+                    }
+                }
+            });
+            const options = convert2PostmanOptions({ requestJson, postmanJSON }, option, eventRuntimeData?.variables || {});
+            const runner = new runtime.Runner();
+
+            runner.run(
+                new sdk.Collection({
+                    info: {
+                        name: _.get(requestJson, "name") || "New request",
+                    },
+                    item: [collection]
+                }), options, (err, run) => {
+                    if (err) {
+                        return;
+                    }
+                    run.start({
+                        // script error
+                        exception(cursor, err) {
+                            if (err) {
+                                const scriptType = _.get(cursor, cursor?.scriptId);
+                                _.set(eventRuntimeData, [event?.event_id, "exception", scriptType], err);
+                                _.set(eventRuntimeData, [event?.event_id, 'error'], {
+                                    error_type: scriptType,
+                                    message: err?.message
+                                })
+                                if (scriptType === 'prerequest') {
+                                    run.abort();
+                                }
+                            }
+                        },
+
+                        // script print
+                        console(cursor, level, ...args) {
+                            if (_.isUndefined(_.get(eventRuntimeData, [event?.event_id, "console"]))) {
+                                _.set(eventRuntimeData, [event?.event_id, "console"], []);
+                            }
+
+                            eventRuntimeData[event?.event_id].console.push({ level, args })
+                        },
+
+                        // Called just before sending a request
+                        beforeRequest(err, cursor, request, item) {
+                            const AllVars = getInsideVariables();
+                            ["variables", "globals", "environment"].forEach((varName) => {
+                                _.assign(AllVars, _.get(eventRuntimeData, `variables.${varName}`))
+                            })
+                            preProcessMockExp(request, postmanJSON, AllVars, _.pick(option, ['lang', 'custom_functions']))
+                        },
+
+                        beforePrerequest(err, cursor, events, item) {
+                            if (!err) {
+                                const pmEvent = convert2PostmanEvent({ requestJson, postmanJSON }, "prerequest", option);
+
+                                _.forEach(pmEvent, (event) => {
+                                    const script = new PostmanEvent(event);
+                                    events.push(script);
+                                    _.set(cursor, script?.script?.id, script?.listen);
+                                });
+                            }
+                        },
+
+                        prerequest(err, cursor, results, item) {
+                            if (!err) {
+                                _.forEach(results, (result) => {
+                                    _.forEach(['_variables', 'environment', 'globals'], (varType) => {
+                                        const currentVar = _.get(result, `result.${varType}`);
+                                        try {
+                                            _.forEach(currentVar.toObject(), (val, key) => {
+                                                _.set(eventRuntimeData, ["variables", varType === '_variables' ? 'variables' : varType, key], val)
+                                            })
+                                        } catch (e) { }
+                                    })
+                                })
+                            }
+                        },
+
+                        response: async (err, cursor, response, request, item, cookies, history) => {
+                            if (!err) {
+                                if (!_.includes(['get_parsed_request'], scene)) {
+                                    _.set(eventRuntimeData, [event?.event_id, "response"], await convert2EchoResponse(response, history));
+                                }
+                            } else {
+                                if (!_.includes(['script', 'sql'], event?.type)) {
+                                    _.set(eventRuntimeData, [event?.event_id, "exception", 'prerequest'], String(err));
+                                    _.set(eventRuntimeData, [event?.event_id, 'error'], {
+                                        error_type: 'prerequest',
+                                        message: String(err)
+                                    })
+                                }
+                            }
+
+                            _.set(eventRuntimeData, [event?.event_id, "request"], convert2EchoRequest(request, requestJson, postmanJSON, history));
+                        },
+
+                        beforeTest(err, cursor, events, item) {
+                            if (!err) {
+                                if (!_.includes(['get_parsed_request'], scene)) {
+                                    const pmEvent = convert2PostmanEvent({ requestJson, postmanJSON }, "test", option);
+                                    _.forEach(pmEvent, (event) => {
+                                        const script = new PostmanEvent(event);
+                                        events.push(script);
+                                        _.set(cursor, script?.script?.id, script?.listen);
+                                    });
+                                }
+                            }
+                        },
+
+                        test(err, cursor, results, item) {
+                            if (!err) {
+                                if (!_.includes(['get_parsed_request'], scene)) {
+                                    _.forEach(results, (result) => {
+                                        _.forEach(['_variables', 'environment', 'globals'], (varType) => {
+                                            const currentVar = _.get(result, `result.${varType}`);
+                                            try {
+                                                _.forEach(currentVar.toObject(), (val, key) => {
+                                                    _.set(eventRuntimeData, ["variables", varType === '_variables' ? 'variables' : varType, key], val)
+                                                })
+                                            } catch (e) { }
+                                        })
+                                    })
+                                }
+                            }
+                        },
+
+                        assertion(cursor, assertions) {
+                            if (!_.includes(['get_parsed_request'], scene)) {
+                                if (!_.isEmpty(assertions) && _.isArray(assertions)) {
+                                    if (_.isUndefined(_.get(eventRuntimeData, [event?.event_id, "assertions"]))) {
+                                        _.set(eventRuntimeData, [event?.event_id, "assertions"], []);
+                                    }
+
+                                    eventRuntimeData[event?.event_id].assertions = _.unionWith(_.concat(_.get(eventRuntimeData, event?.event_id, "assertions"), assertions), _.isEqual);
+                                }
+                            }
+                        },
+
+                        item(err, cursor, item, visualizer, result) {
+                            if (!err && _.isObject(visualizer)) {
+                                const { error, processed_template } = visualizer;
+                                _.set(eventRuntimeData[event?.event_id], "visualizer", { error, processed_template });
+                            } else {
+                                _.set(eventRuntimeData[event?.event_id], "visualizer", { error: null, processed_template: "" });
+                            }
+                        },
+
+                        responseData(cursor, data) {
+                            callback({
+                                action: "sse",
+                                data: {
+                                    stream: data,
+                                    size: _.size(data),
+                                    time: Date.now()
+                                },
+                                msg: "success",
+                                error: null,
+                            })
+                        },
+
+                        done(err, summary) {
+                            if (!_.includes(['get_parsed_request'], scene)) {
+                                if (!err) {
+                                    const success_assert = _.map(_.get(eventRuntimeData, [event?.event_id, "assertions"]), (item) => {
+                                        return item?.passed === false
+                                    })
+
+                                    _.set(eventRuntimeData, [event?.event_id, "status"], {
+                                        assert: [event?.event_id, "assertions"],
+                                        success_assert,
+                                        http: _.get(eventRuntimeData, [event?.event_id, 'response', 'status']) || _.get(eventRuntimeData, [event?.event_id, 'error', 'message'])
+                                    });
+                                }
+
+                                // 写入到自动化测试结果
+                                if (scene === 'auto_test' && _.includes(['assert', 'assert_visual', 'api', 'sample'], event?.type)) {
+                                    eventResultList.push(_.assign(_.get(eventRuntimeData, event?.event_id), _.pick(event, ['type', 'event_id', 'test_id']), {
+                                        iteration_id: aTools.snowflakeId()
+                                    }))
+                                }
+                            }
+
+                            resolve({
+                                action: 'httpRequestCompleted',
+                                data: _.get(eventRuntimeData, event?.event_id),
+                                error: _.get(eventRuntimeData, [event?.event_id, 'error', 'message']) || null,
+                                event_id: event?.event_id,
+                                target_id: requestJson?.target_id
+                            })
+                        }
+                    })
+                }
+            );
+        } catch (e) {
+            resolve({
+                action: 'stystemError',
+                message: String(e),
+                current_event_id: event?.event_id
+            })
+        }
+    });
+}