cvitool 1.0.743 → 1.0.745

package/build/src/cutil.d.ts

@@ -10,6 +10,9 @@ interface randomStringOptions {
     number?: boolean;
     specials?: string;
 }
+interface CustomObject {
+    [key: string]: any;
+}
 interface getMediaFileTypeRes {
     type: string;
     extname: string;
@@ -22,4 +25,6 @@ declare function execCmdCommand(command: string, timeout?: number): Promise<unkn
 declare function getValueType(value: any): "string" | "number" | "boolean" | "undefined" | "object" | "array" | "null" | "unkonw";
 declare function getMediaFileType(target: string | Buffer | ReadStream): Promise<getMediaFileTypeRes>;
 declare function checkURLResource(url: string): Promise<boolean>;
-export { randomStringOptions, getMediaFileTypeRes, randomString, encryptCBC, decryptCBC, md5, execCmdCommand, getValueType, getMediaFileType, checkURLResource };
+declare function writeJsonFileSync(data: CustomObject | CustomObject[] | string, path: string, space?: number): void;
+declare function readJsonFileSync(path: string, toObj?: boolean): CustomObject | CustomObject[] | string;
+export { randomStringOptions, getMediaFileTypeRes, CustomObject, randomString, encryptCBC, decryptCBC, md5, execCmdCommand, getValueType, getMediaFileType, checkURLResource, writeJsonFileSync, readJsonFileSync };

package/build/src/cutil.js

@@ -9,9 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkURLResource = exports.getMediaFileType = exports.getValueType = exports.execCmdCommand = exports.md5 = exports.decryptCBC = exports.encryptCBC = exports.randomString = void 0;
+exports.readJsonFileSync = exports.writeJsonFileSync = exports.checkURLResource = exports.getMediaFileType = exports.getValueType = exports.execCmdCommand = exports.md5 = exports.decryptCBC = exports.encryptCBC = exports.randomString = void 0;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
+const fs_1 = require("fs");
 const hgo = require("./hgo");
 function randomString(length, options) {
     let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
@@ -68,29 +69,29 @@ function md5(data, inputEncoding = 'utf-8') {
     return (0, crypto_1.createHash)('md5').update(data, inputEncoding).digest('hex');
 }
 exports.md5 = md5;
-function execCmdCommand(command, timeout = 5 * 60 * 1000) {
+function execCmdCommand(command, timeout = 1 * 60 * 1000) {
     return __awaiter(this, void 0, void 0, function* () {
         const commandList = command.split(' ');
         const commandName = commandList.splice(0, 1);
         return new Promise((resolve, reject) => {
             const chunks = [];
-            const cmd = (0, child_process_1.spawn)(commandName[0], commandList, { stdio: 'pipe', shell: true, timeout });
+            const cmd = (0, child_process_1.spawn)(commandName[0], commandList, { stdio: 'pipe', shell: true, timeout, killSignal: 'SIGKILL' });
             cmd.stdout.on('data', chunk => {
                 chunks.push(chunk);
             });
             cmd.stderr.on('data', chunk => {
                 chunks.push(chunk);
             });
-            cmd.on('exit', (code) => {
+            cmd.on('exit', (code, signal) => {
                 const result = Buffer.concat(chunks).toString();
                 if (code !== 0) {
                     const customErr = new Error();
-                    if (code === 255) {
-                        customErr.message = `timeout in ${timeout}ms`;
+                    if (signal === 'SIGKILL') {
+                        customErr.message = `execCmdCommand|timeout in ${timeout}ms`;
                         customErr.name = 'timeoutError';
                     }
                     else {
-                        customErr.message = result;
+                        customErr.message = `execCmdCommand|${result}`;
                         customErr.name = 'unknowError';
                     }
                     reject(customErr);
@@ -258,9 +259,31 @@ function checkURLResource(url) {
             yield hgo.get(url, { headers: { Range: 'bytes=0-0' }, resType: 'buffer' });
         }
         catch (e) {
+            if (e.name === 'timeoutError') {
+                throw e;
+            }
             isEffective = false;
         }
         return isEffective;
     });
 }
 exports.checkURLResource = checkURLResource;
+function writeJsonFileSync(data, path, space = 3) {
+    let writeStr = '';
+    if (getValueType(data) === 'string') {
+        writeStr = data;
+    }
+    else {
+        writeStr = JSON.stringify(data, undefined, space);
+    }
+    (0, fs_1.writeFileSync)(path, writeStr);
+}
+exports.writeJsonFileSync = writeJsonFileSync;
+function readJsonFileSync(path, toObj = true) {
+    const str = (0, fs_1.readFileSync)(path).toString();
+    if (toObj) {
+        return JSON.parse(str);
+    }
+    return str;
+}
+exports.readJsonFileSync = readJsonFileSync;

package/build/src/hgo.d.ts

@@ -19,6 +19,8 @@ interface baseReqOptions {
     resType?: ResType;
     connectTimeOut?: number;
     readTimeOut?: number;
+    useEnvProxy?: boolean;
+    proxyHost?: string;
 }
 interface reqOptions extends baseReqOptions {
     method?: Method;

package/build/src/hgo.js

@@ -15,10 +15,8 @@ const https = require("https");
 const http = require("http");
 function buildTimeOutErr(type, timeout, reqUrl) {
     const err = new Error();
-    err.code = 'TimeOut';
-    err.name = `${type}Error`;
-    err.message = `${type} for ${timeout} ms`;
-    err.reqUrl = reqUrl;
+    err.name = 'timeoutError';
+    err.message = `request '${reqUrl}'|${type} in ${timeout} ms`;
     return err;
 }
 function getProtocol(url) {
@@ -26,7 +24,7 @@ function getProtocol(url) {
 }
 function request(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds } = options || {};
+        let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds, useEnvProxy = true, proxyHost } = options || {};
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
@@ -40,7 +38,6 @@ function request(url, options) {
             }
         }
         const data = JSON.stringify(body);
-        const protocol = getProtocol(url);
         const isbodyEmpty = Object.keys(body).length === 0;
         let baseHeaders = {};
         if (!isbodyEmpty) {
@@ -50,15 +47,11 @@ function request(url, options) {
             };
         }
         let res;
+        const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
         try {
             res = yield new Promise((resolve, reject) => {
-                const req = protocol.request(url, {
-                    timeout: connectTimeOut,
-                    headers: Object.assign(headers, baseHeaders),
-                    method,
-                    agent
-                }, res => {
-                    resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+                const req = reqProtocol.request(reqOpt, res => {
+                    resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
                 });
                 req.on('timeout', () => {
                     req.destroy();
@@ -102,22 +95,20 @@ function request(url, options) {
 exports.request = request;
 function reqSendBuffer(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds } = options;
+        let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds, useEnvProxy = true, proxyHost } = options;
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
         }
-        const protocol = getProtocol(url);
+        const baseHeaders = {
+            'Content-Length': buffer.byteLength
+        };
+        const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
         let res;
         try {
             res = yield new Promise((resolve, reject) => {
-                const req = protocol.request(url, {
-                    timeout: connectTimeOut,
-                    headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
-                    method,
-                    agent
-                }, res => {
-                    resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+                const req = reqProtocol.request(reqOpt, res => {
+                    resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
                 });
                 req.on('timeout', () => {
                     req.destroy();
@@ -156,25 +147,20 @@ function reqSendBuffer(url, options) {
 exports.reqSendBuffer = reqSendBuffer;
 function reqSendStream(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        let { timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut, useEnvProxy = true, proxyHost } = options;
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
         }
-        const protocol = getProtocol(url);
+        const baseHeaders = {
+            'Content-Type': 'application/octet-stream',
+            'Transfer-Encoding': 'chunked',
+            Connection: 'keep-alive'
+        };
+        const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
         const res = yield new Promise((resolve, reject) => {
-            const baseHeaders = {
-                'Content-Type': 'application/octet-stream',
-                'Transfer-Encoding': 'chunked',
-                Connection: 'keep-alive'
-            };
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, baseHeaders),
-                method,
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+            const req = reqProtocol.request(reqOpt, res => {
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
             });
             req.on('timeout', () => {
                 req.destroy();
@@ -208,20 +194,16 @@ function reqSendStream(url, options) {
 exports.reqSendStream = reqSendStream;
 function reqSendMultiPart(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        let { timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut, useEnvProxy = true, proxyHost } = options;
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
         }
-        const protocol = getProtocol(url);
+        const baseHeaders = Object.assign({}, form.getHeaders());
+        const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, 'post', agent, useEnvProxy, proxyHost);
         const res = yield new Promise((resolve, reject) => {
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, Object.assign({}, form.getHeaders())),
-                method: 'post',
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, 'post', readTimeOut, req);
+            const req = reqProtocol.request(reqOpt, res => {
+                resHandld(res, resolve, reject, resType, 'post', readTimeOut, req, url);
             });
             req.on('timeout', () => {
                 req.destroy();
@@ -246,8 +228,7 @@ function reqSendMultiPart(url, options) {
     });
 }
 exports.reqSendMultiPart = reqSendMultiPart;
-function resHandld(res, resolve, reject, resType, method, readTimeOut, req) {
-    const reqUrl = `${res.req.protocol}//${res.req.host}${res.req.path}`;
+function resHandld(res, resolve, reject, resType, method, readTimeOut, req, reqUrl) {
     const resHeaders = {};
     for (let i = 0; i < res.rawHeaders.length; i += 2) {
         resHeaders[res.rawHeaders[i]] = res.rawHeaders[i + 1];
@@ -385,3 +366,37 @@ function head(url, options) {
     });
 }
 exports.head = head;
+function getReqProtocolAndOpt(url, baseHeaders, headers, timeout, method, agent, useEnvProxy, proxyHost) {
+    let reqProtocol = getProtocol(url);
+    const urlOpt = new URL(url);
+    let reqOpt = {
+        host: urlOpt.hostname,
+        port: urlOpt.port,
+        path: `${urlOpt.pathname}${urlOpt.search}`,
+        timeout,
+        headers: Object.assign(headers, baseHeaders),
+        method,
+        agent
+    };
+    if (proxyHost || (((urlOpt.protocol === 'https:' && process.env.https_proxy) || (urlOpt.protocol === 'http:' && process.env.http_proxy)) && useEnvProxy)) {
+        const proxyHostStr = proxyHost || (urlOpt.protocol === 'https:' ? process.env.https_proxy : process.env.http_proxy);
+        const proxyUrlOpt = new URL(proxyHostStr);
+        const proxyHeaders = {
+            Host: `${urlOpt.hostname}:${urlOpt.port || (urlOpt.protocol === 'http:' ? 80 : 443)}`
+        };
+        reqOpt = {
+            host: proxyUrlOpt.hostname,
+            port: proxyUrlOpt.port,
+            path: url,
+            timeout,
+            headers: Object.assign(headers, baseHeaders, proxyHeaders),
+            method,
+            agent
+        };
+        reqProtocol = proxyUrlOpt.protocol === 'https:' ? https : http;
+    }
+    return {
+        reqProtocol,
+        reqOpt
+    };
+}

package/index.d.ts

@@ -16,7 +16,8 @@ import {
 
 import {
     randomStringOptions,
-    getMediaFileTypeRes
+    getMediaFileTypeRes,
+    CustomObject
 } from './src/cutil';
 
 interface Hgo {
@@ -138,6 +139,19 @@ interface Cutil {
      * @param url 
      */
     checkURLResource(url: string): Promise<boolean>
+    /**
+     * 写入json文件
+     * @param data 
+     * @param path 
+     * @param space 
+     */
+    writeJsonFileSync(data: CustomObject | CustomObject[] | string, path: string, space?: number): void
+    /**
+     * 读取json文件
+     * @param path 
+     * @param toObj 
+     */
+    readJsonFileSync(path: string, toObj?: boolean): CustomObject | CustomObject[] | string
 }
 
 declare const hgo: Hgo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvitool",
-  "version": "1.0.743",
+  "version": "1.0.745",
   "description": "cvitool",
   "main": "index.js",
   "scripts": {

package/src/cutil.ts

@@ -8,7 +8,7 @@ import {
 import {
     spawn
 } from 'child_process';
-import { ReadStream } from 'fs';
+import { ReadStream, writeFileSync, readFileSync } from 'fs';
 import * as hgo from './hgo';
 
 interface randomStringOptions {
@@ -19,6 +19,10 @@ interface randomStringOptions {
     specials?: string
 }
 
+interface CustomObject {
+    [key: string]: any
+}
+
 interface getMediaFileTypeRes {
     type: string,
     extname: string
@@ -77,27 +81,27 @@ function md5(data: string, inputEncoding: Encoding = 'utf-8') {
     return createHash('md5').update(data, inputEncoding).digest('hex');
 }
 
-async function execCmdCommand(command: string, timeout = 5 * 60 * 1000) {
+async function execCmdCommand(command: string, timeout = 1 * 60 * 1000) {
     const commandList = command.split(' ');
     const commandName = commandList.splice(0, 1);
     return new Promise((resolve, reject) => {
         const chunks = [];
-        const cmd = spawn(commandName[0], commandList, { stdio: 'pipe', shell: true, timeout });
+        const cmd = spawn(commandName[0], commandList, { stdio: 'pipe', shell: true, timeout, killSignal: 'SIGKILL' });
         cmd.stdout.on('data', chunk => {
             chunks.push(chunk);
         });
         cmd.stderr.on('data', chunk => {
             chunks.push(chunk);
         });
-        cmd.on('exit', (code) => {
+        cmd.on('exit', (code, signal) => {
             const result = Buffer.concat(chunks).toString();
             if (code !== 0) {
                 const customErr = new Error();
-                if (code === 255) {
-                    customErr.message = `timeout in ${timeout}ms`;
+                if (signal === 'SIGKILL') {
+                    customErr.message = `execCmdCommand|timeout in ${timeout}ms`;
                     customErr.name = 'timeoutError';
                 } else {
-                    customErr.message = result;
+                    customErr.message = `execCmdCommand|${result}`;
                     customErr.name = 'unknowError';
                 }
                 reject(customErr);
@@ -260,14 +264,36 @@ async function checkURLResource(url: string) {
     try {
         await hgo.get(url, { headers: { Range: 'bytes=0-0' }, resType: 'buffer' });
     } catch (e) {
+        if (e.name === 'timeoutError') {
+            throw e;
+        }
         isEffective = false;
     }
     return isEffective;
 }
 
+function writeJsonFileSync(data: CustomObject | CustomObject[] | string, path: string, space = 3) {
+    let writeStr = '';
+    if (getValueType(data) === 'string') {
+        writeStr = data as string;
+    } else {
+        writeStr = JSON.stringify(data, undefined, space);
+    }
+    writeFileSync(path, writeStr);
+}
+
+function readJsonFileSync(path: string, toObj = true): CustomObject | CustomObject[] | string {
+    const str = readFileSync(path).toString();
+    if (toObj) {
+        return JSON.parse(str);
+    }
+    return str;
+}
+
 export {
     randomStringOptions,
     getMediaFileTypeRes,
+    CustomObject,
     randomString,
     encryptCBC,
     decryptCBC,
@@ -275,5 +301,7 @@ export {
     execCmdCommand,
     getValueType,
     getMediaFileType,
-    checkURLResource
+    checkURLResource,
+    writeJsonFileSync,
+    readJsonFileSync
 };

package/src/hgo.ts

@@ -18,7 +18,9 @@ interface baseReqOptions {
     },
     resType?: ResType,
     connectTimeOut?: number,
-    readTimeOut?: number
+    readTimeOut?: number,
+    useEnvProxy?: boolean,
+    proxyHost?: string
 }
 
 interface reqOptions extends baseReqOptions {
@@ -70,12 +72,10 @@ interface ResData {
 }
 
 function buildTimeOutErr(type: 'connectTimeOut' | 'readTimeOut', timeout: number, reqUrl?: string) {
-    const err: any = new Error();
-    err.code = 'TimeOut';
-    err.name = `${type}Error`;
-    err.message = `${type} for ${timeout} ms`;
-    err.reqUrl = reqUrl;
-    return err as Error;
+    const err = new Error();
+    err.name = 'timeoutError';
+    err.message = `request '${reqUrl}'|${type} in ${timeout} ms`;
+    return err;
 }
 
 function getProtocol(url: string) {
@@ -85,7 +85,7 @@ function getProtocol(url: string) {
 async function request(url: string, options?: reqOptions): Promise<ResData> {
     let {
         query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut,
-        readTimeOut, retries, retryInterval, retrieds
+        readTimeOut, retries, retryInterval, retrieds, useEnvProxy = true, proxyHost
     } = options || {};
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
@@ -99,7 +99,6 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
         }
     }
     const data = JSON.stringify(body);
-    const protocol = getProtocol(url);
     const isbodyEmpty = Object.keys(body).length === 0;
     let baseHeaders: CustomObject = {};
     if (!isbodyEmpty) {
@@ -109,15 +108,11 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
         };
     }
     let res: ResData;
+    const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
     try {
         res = await new Promise((resolve, reject) => {
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, baseHeaders),
-                method,
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+            const req = reqProtocol.request(reqOpt, res => {
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
             });
             req.on('timeout', () => {
                 req.destroy();
@@ -159,23 +154,21 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
 async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData> {
     let {
         timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut,
-        retries, retryInterval, retrieds
+        retries, retryInterval, retrieds, useEnvProxy = true, proxyHost
     } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
-    const protocol = getProtocol(url);
+    const baseHeaders = {
+        'Content-Length': buffer.byteLength
+    };
+    const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
     let res: ResData;
     try {
         res = await new Promise((resolve, reject) => {
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
-                method,
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+            const req = reqProtocol.request(reqOpt, res => {
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
             });
             req.on('timeout', () => {
                 req.destroy();
@@ -212,26 +205,22 @@ async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promis
 
 async function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData> {
     let {
-        timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut
+        timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut,
+        useEnvProxy = true, proxyHost
     } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
-    const protocol = getProtocol(url);
+    const baseHeaders = {
+        'Content-Type': 'application/octet-stream',
+        'Transfer-Encoding': 'chunked',
+        Connection: 'keep-alive'
+    };
+    const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, method, agent, useEnvProxy, proxyHost);
     const res: ResData = await new Promise((resolve, reject) => {
-        const baseHeaders = {
-            'Content-Type': 'application/octet-stream',
-            'Transfer-Encoding': 'chunked',
-            Connection: 'keep-alive'
-        };
-        const req = protocol.request(url, {
-            timeout: connectTimeOut,
-            headers: Object.assign(headers, baseHeaders),
-            method,
-            agent
-        }, res => {
-            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+        const req = reqProtocol.request(reqOpt, res => {
+            resHandld(res, resolve, reject, resType, method, readTimeOut, req, url);
         });
         req.on('timeout', () => {
             req.destroy();
@@ -264,21 +253,20 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
 
 async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData> {
     let {
-        timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut
+        timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut,
+        useEnvProxy = true, proxyHost
     } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
-    const protocol = getProtocol(url);
+    const baseHeaders = {
+        ...form.getHeaders()
+    };
+    const { reqProtocol, reqOpt } = getReqProtocolAndOpt(url, baseHeaders, headers, connectTimeOut, 'post', agent, useEnvProxy, proxyHost);
     const res: ResData = await new Promise((resolve, reject) => {
-        const req = protocol.request(url, {
-            timeout: connectTimeOut,
-            headers: Object.assign(headers, { ...form.getHeaders() }),
-            method: 'post',
-            agent
-        }, res => {
-            resHandld(res, resolve, reject, resType, 'post', readTimeOut, req);
+        const req = reqProtocol.request(reqOpt, res => {
+            resHandld(res, resolve, reject, resType, 'post', readTimeOut, req, url);
         });
         req.on('timeout', () => {
             req.destroy();
@@ -302,8 +290,7 @@ async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions):
     return res;
 }
 
-function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method, readTimeOut: number, req: http.ClientRequest) {
-    const reqUrl = `${(res as any).req.protocol}//${(res as any).req.host}${(res as any).req.path}`;
+function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method, readTimeOut: number, req: http.ClientRequest, reqUrl: string) {
     const resHeaders: CustomObject = {};
     for (let i = 0; i < res.rawHeaders.length; i += 2) {
         resHeaders[res.rawHeaders[i]] = res.rawHeaders[i + 1];
@@ -432,6 +419,42 @@ async function head(url: string, options?: methodReqOptions) {
     return request(url, { ...options, method: 'head' });
 }
 
+function getReqProtocolAndOpt(url: string, baseHeaders: CustomObject, headers: CustomObject, timeout: number, method: Method, agent: http.Agent | https.Agent,
+    useEnvProxy: boolean, proxyHost: string) {
+    let reqProtocol = getProtocol(url);
+    const urlOpt = new URL(url);
+    let reqOpt = {
+        host: urlOpt.hostname,
+        port: urlOpt.port,
+        path: `${urlOpt.pathname}${urlOpt.search}`,
+        timeout,
+        headers: Object.assign(headers, baseHeaders),
+        method,
+        agent
+    };
+    if (proxyHost || (((urlOpt.protocol === 'https:' && process.env.https_proxy) || (urlOpt.protocol === 'http:' && process.env.http_proxy)) && useEnvProxy)) {
+        const proxyHostStr = proxyHost || (urlOpt.protocol === 'https:' ? process.env.https_proxy : process.env.http_proxy);
+        const proxyUrlOpt = new URL(proxyHostStr);
+        const proxyHeaders = {
+            Host: `${urlOpt.hostname}:${urlOpt.port || (urlOpt.protocol === 'http:' ? 80 : 443)}`
+        };
+        reqOpt = {
+            host: proxyUrlOpt.hostname,
+            port: proxyUrlOpt.port,
+            path: url,
+            timeout,
+            headers: Object.assign(headers, baseHeaders, proxyHeaders),
+            method,
+            agent
+        };
+        reqProtocol = proxyUrlOpt.protocol === 'https:' ? https : http;
+    }
+    return {
+        reqProtocol,
+        reqOpt
+    };
+}
+
 export {
     reqOptions,
     methodReqOptions,