@smythos/sre 1.6.8 → 1.6.10

package/src/Components/APICall/mimeTypeCategories.ts

@@ -1,46 +1,46 @@
-const mimeTypeCategories = {
-    binary: [
-        'image/',
-        'multipart/form-data',
-        'video/',
-        'application/msword',
-        'application/octet-stream',
-        'application/pdf',
-        'application/vnd.ms-excel',
-        'application/vnd.ms-powerpoint',
-        'application/vnd.oasis.opendocument.text',
-        'application/vnd.openxmlformats-officedocument',
-        'application/zip',
-        'application/x-7z-compressed',
-        'application/x-rar-compressed',
-        'application/x-tar',
-        'application/x-bzip',
-        'application/x-bzip2',
-        'application/x-gzip',
-        'application/vnd.android.package-archive',
-        'application/vnd.visio',
-        'application/x-deb',
-        'application/x-rpm',
-        'application/x-executable',
-        'font/ttf',
-        'font/otf',
-        'font/woff',
-        'font/woff2',
-        'model/',
-    ],
-    json: ['application/graphql', 'application/json', 'application/ld+json', 'application/vnd.api+json'],
-    text: [
-        'text/', //all starting with text/
-        'application/xml',
-        'application/xhtml+xml',
-        'application/csv',
-        'application/x-www-form-urlencoded',
-        'application/x-yaml',
-        'application/yaml',
-        'application/javascript',
-        'application/sql',
-        'application/rtf',
-    ],
-};
-
-export default mimeTypeCategories;
+const mimeTypeCategories = {
+    binary: [
+        'image/',
+        'multipart/form-data',
+        'video/',
+        'application/msword',
+        'application/octet-stream',
+        'application/pdf',
+        'application/vnd.ms-excel',
+        'application/vnd.ms-powerpoint',
+        'application/vnd.oasis.opendocument.text',
+        'application/vnd.openxmlformats-officedocument',
+        'application/zip',
+        'application/x-7z-compressed',
+        'application/x-rar-compressed',
+        'application/x-tar',
+        'application/x-bzip',
+        'application/x-bzip2',
+        'application/x-gzip',
+        'application/vnd.android.package-archive',
+        'application/vnd.visio',
+        'application/x-deb',
+        'application/x-rpm',
+        'application/x-executable',
+        'font/ttf',
+        'font/otf',
+        'font/woff',
+        'font/woff2',
+        'model/',
+    ],
+    json: ['application/graphql', 'application/json', 'application/ld+json', 'application/vnd.api+json'],
+    text: [
+        'text/', //all starting with text/
+        'application/xml',
+        'application/xhtml+xml',
+        'application/csv',
+        'application/x-www-form-urlencoded',
+        'application/x-yaml',
+        'application/yaml',
+        'application/javascript',
+        'application/sql',
+        'application/rtf',
+    ],
+};
+
+export default mimeTypeCategories;

package/src/Components/APICall/parseData.ts

@@ -1,167 +1,167 @@
-import { Agent } from '@sre/AgentManager/Agent.class';
-import { REQUEST_CONTENT_TYPES } from '@sre/constants';
-import { JSONContent } from '@sre/helpers/JsonContent.helper';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
-import FormData from 'form-data';
-import { Readable } from 'stream';
-
-export async function parseData(input: any, config, agent: Agent): Promise<{ data: any; headers: any }> {
-    const teamId = agent ? agent.teamId : null;
-    const templateSettings = config?.template?.settings || {};
-    const contentType = config?.data?.contentType || REQUEST_CONTENT_TYPES.none;
-
-    let body = typeof config?.data?.body === 'string' ? config?.data?.body?.trim() : config?.data?.body;
-    if (!body) {
-        return { data: null, headers: {} };
-    }
-
-    // Parse component template variables
-    if (config.data._templateVars && templateSettings) {
-        //prettier-ignore
-        body = await TemplateString(body) 
-            .parseComponentTemplateVarsAsync(templateSettings) // replace component template vars with their IDs (this turns the string parses into an async parser)            
-            .asyncResult; //returns parser promise
-    }
-
-    // Parse vault keys
-    body = await TemplateString(body).parseTeamKeysAsync(teamId).asyncResult;
-
-    // Handle different content types
-    const handlers: Record<string, (parsedBody: any, input: any, config, agent: Agent) => any> = {
-        [REQUEST_CONTENT_TYPES.json]: handleJson,
-        [REQUEST_CONTENT_TYPES.urlEncodedFormData]: handleUrlEncoded,
-        [REQUEST_CONTENT_TYPES.multipartFormData]: handleMultipartFormData,
-        [REQUEST_CONTENT_TYPES.binary]: handleBinary,
-        [REQUEST_CONTENT_TYPES.text]: handleText,
-        [REQUEST_CONTENT_TYPES.none]: handleNone,
-    };
-
-    const handler = handlers[contentType] || handleNone;
-    const { data = null, headers = {} } = await handler(body, input, config, agent);
-
-    //const jsonBody: any = JSONContent(data).tryParse();
-    return { data, headers };
-}
-
-async function handleJson(body: any, input: any, config, agent: Agent) {
-    // Parse template and input variables
-    //prettier-ignore
-    const data = TemplateString(body)
-        .parse(config.data._templateVars) //parse Template variables first (if any)
-        .parse(input) //parse inputs
-        .clean().result; //clean up the remaining unparsed values
-
-    const jsonBody: any = JSONContent(data).tryParse();
-    return { data: jsonBody };
-}
-
-async function handleUrlEncoded(body: any, input: any, config, agent: Agent) {
-    const data = TemplateString(body)
-        .parse(config.data._templateVars) //parse Template variables first (if any)
-        .parse(input) //parse inputs
-        .clean().result; //clean up the remaining unparsed values
-
-    const jsonData: any = JSONContent(data).tryParse();
-
-    if (typeof jsonData === 'object') {
-        const params = new URLSearchParams();
-        for (const key in jsonData) {
-            params.append(key, String(jsonData[key]));
-        }
-        return { data: params.toString() };
-    }
-
-    return { data: jsonData };
-}
-
-async function handleMultipartFormData(body: any, input: any, config, agent: Agent) {
-    const formData = new FormData();
-
-    const _body = typeof body === 'string' ? JSON.parse(body) : body;
-
-    for (const key in _body) {
-        let value = _body[key];
-        value = typeof value === 'boolean' ? String(value) : value;
-
-        value = TemplateString(value).parseRaw(input).result;
-
-        // * Note: It's important to check if the value is an instance of BinaryInput first.
-        // Otherwise, condition like (value && typeof value === 'object' && value?.url)
-        // might be true and lead to incorrect results.
-        if (value instanceof BinaryInput) {
-            const buffer = await value.getBuffer();
-            const bufferStream = new Readable();
-            bufferStream.push(buffer || null);
-            bufferStream.push(null);
-
-            const filename = (await value.getName()) || key;
-            formData.append(key, bufferStream, {
-                filename,
-                contentType: value.mimetype,
-            });
-        } else if (value && typeof value === 'object' && value?.url) {
-            // Retro compatibility with old binary data structure {url: '...', mimetype: '...', url: 'http(s)://...'}
-            const binaryInput = await BinaryInput.from(value.url, '', value?.mimetype);
-            const buffer = await binaryInput.getBuffer();
-
-            const bufferStream = new Readable();
-            bufferStream.push(buffer || null);
-            bufferStream.push(null);
-
-            const filename = (await binaryInput.getName()) || key;
-            formData.append(key, bufferStream, {
-                filename,
-                contentType: binaryInput.mimetype,
-            });
-        } else {
-            value = TemplateString(value)
-                .parse(config.data._templateVars) //parse Template variables first (if any)
-                .parse(input)
-                .clean().result;
-
-            if (value) {
-                formData.append(key, value);
-            }
-
-            //formData.append(key, typeof value === 'boolean' ? String(value) : value);
-        }
-    }
-    return { data: formData, headers: formData.getHeaders() };
-}
-
-async function handleBinary(body: any, input: any, config, agent: Agent) {
-    const value: any = TemplateString(body).parseRaw(input).result;
-
-    // * Note: It's important to check if the value is an instance of BinaryInput first.
-    // Otherwise, condition like (value && typeof value === 'object' && value?.url)
-    // might be true and lead to incorrect results.
-    if (value && value instanceof BinaryInput) {
-        const buffer = await value.getBuffer();
-        return { data: buffer, headers: { 'Content-Type': value.mimetype } };
-    } else if (value && typeof value === 'object' && value?.url) {
-        // Retro compatibility with old binary data structure {url: '...', mimetype: '...', url: 'http(s)://...'}
-        const binaryInput = await BinaryInput.from(value.url, '', value?.mimetype);
-        const buffer = await binaryInput.getBuffer();
-
-        return { data: buffer, headers: { 'Content-Type': binaryInput.mimetype } };
-    }
-
-    return { data: Buffer.from([]), headers: {} };
-}
-
-async function handleNone(body: any, input: any, config, agent: Agent) {
-    //FIXME: try to guess the content type from headers content-type and data
-
-    return { data: typeof body === 'string' ? body : JSON.stringify(body), headers: {} };
-}
-function handleText(body: any, input: any, config: any, agent: Agent) {
-    // Parse template and input variables
-    //prettier-ignore
-    const data = TemplateString(body)
-        .parse(config.data._templateVars) //parse Template variables first (if any)
-        .parse(input) //parse inputs
-        .clean().result; //clean up the remaining unparsed values
-
-    return { data };
-}
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { REQUEST_CONTENT_TYPES } from '@sre/constants';
+import { JSONContent } from '@sre/helpers/JsonContent.helper';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import FormData from 'form-data';
+import { Readable } from 'stream';
+
+export async function parseData(input: any, config, agent: Agent): Promise<{ data: any; headers: any }> {
+    const teamId = agent ? agent.teamId : null;
+    const templateSettings = config?.template?.settings || {};
+    const contentType = config?.data?.contentType || REQUEST_CONTENT_TYPES.none;
+
+    let body = typeof config?.data?.body === 'string' ? config?.data?.body?.trim() : config?.data?.body;
+    if (!body) {
+        return { data: null, headers: {} };
+    }
+
+    // Parse component template variables
+    if (config.data._templateVars && templateSettings) {
+        //prettier-ignore
+        body = await TemplateString(body) 
+            .parseComponentTemplateVarsAsync(templateSettings) // replace component template vars with their IDs (this turns the string parses into an async parser)            
+            .asyncResult; //returns parser promise
+    }
+
+    // Parse vault keys
+    body = await TemplateString(body).parseTeamKeysAsync(teamId).asyncResult;
+
+    // Handle different content types
+    const handlers: Record<string, (parsedBody: any, input: any, config, agent: Agent) => any> = {
+        [REQUEST_CONTENT_TYPES.json]: handleJson,
+        [REQUEST_CONTENT_TYPES.urlEncodedFormData]: handleUrlEncoded,
+        [REQUEST_CONTENT_TYPES.multipartFormData]: handleMultipartFormData,
+        [REQUEST_CONTENT_TYPES.binary]: handleBinary,
+        [REQUEST_CONTENT_TYPES.text]: handleText,
+        [REQUEST_CONTENT_TYPES.none]: handleNone,
+    };
+
+    const handler = handlers[contentType] || handleNone;
+    const { data = null, headers = {} } = await handler(body, input, config, agent);
+
+    //const jsonBody: any = JSONContent(data).tryParse();
+    return { data, headers };
+}
+
+async function handleJson(body: any, input: any, config, agent: Agent) {
+    // Parse template and input variables
+    //prettier-ignore
+    const data = TemplateString(body)
+        .parse(config.data._templateVars) //parse Template variables first (if any)
+        .parse(input) //parse inputs
+        .clean().result; //clean up the remaining unparsed values
+
+    const jsonBody: any = JSONContent(data).tryParse();
+    return { data: jsonBody };
+}
+
+async function handleUrlEncoded(body: any, input: any, config, agent: Agent) {
+    const data = TemplateString(body)
+        .parse(config.data._templateVars) //parse Template variables first (if any)
+        .parse(input) //parse inputs
+        .clean().result; //clean up the remaining unparsed values
+
+    const jsonData: any = JSONContent(data).tryParse();
+
+    if (typeof jsonData === 'object') {
+        const params = new URLSearchParams();
+        for (const key in jsonData) {
+            params.append(key, String(jsonData[key]));
+        }
+        return { data: params.toString() };
+    }
+
+    return { data: jsonData };
+}
+
+async function handleMultipartFormData(body: any, input: any, config, agent: Agent) {
+    const formData = new FormData();
+
+    const _body = typeof body === 'string' ? JSON.parse(body) : body;
+
+    for (const key in _body) {
+        let value = _body[key];
+        value = typeof value === 'boolean' ? String(value) : value;
+
+        value = TemplateString(value).parseRaw(input).result;
+
+        // * Note: It's important to check if the value is an instance of BinaryInput first.
+        // Otherwise, condition like (value && typeof value === 'object' && value?.url)
+        // might be true and lead to incorrect results.
+        if (value instanceof BinaryInput) {
+            const buffer = await value.getBuffer();
+            const bufferStream = new Readable();
+            bufferStream.push(buffer || null);
+            bufferStream.push(null);
+
+            const filename = (await value.getName()) || key;
+            formData.append(key, bufferStream, {
+                filename,
+                contentType: value.mimetype,
+            });
+        } else if (value && typeof value === 'object' && value?.url) {
+            // Retro compatibility with old binary data structure {url: '...', mimetype: '...', url: 'http(s)://...'}
+            const binaryInput = await BinaryInput.from(value.url, '', value?.mimetype);
+            const buffer = await binaryInput.getBuffer();
+
+            const bufferStream = new Readable();
+            bufferStream.push(buffer || null);
+            bufferStream.push(null);
+
+            const filename = (await binaryInput.getName()) || key;
+            formData.append(key, bufferStream, {
+                filename,
+                contentType: binaryInput.mimetype,
+            });
+        } else {
+            value = TemplateString(value)
+                .parse(config.data._templateVars) //parse Template variables first (if any)
+                .parse(input)
+                .clean().result;
+
+            if (value) {
+                formData.append(key, value);
+            }
+
+            //formData.append(key, typeof value === 'boolean' ? String(value) : value);
+        }
+    }
+    return { data: formData, headers: formData.getHeaders() };
+}
+
+async function handleBinary(body: any, input: any, config, agent: Agent) {
+    const value: any = TemplateString(body).parseRaw(input).result;
+
+    // * Note: It's important to check if the value is an instance of BinaryInput first.
+    // Otherwise, condition like (value && typeof value === 'object' && value?.url)
+    // might be true and lead to incorrect results.
+    if (value && value instanceof BinaryInput) {
+        const buffer = await value.getBuffer();
+        return { data: buffer, headers: { 'Content-Type': value.mimetype } };
+    } else if (value && typeof value === 'object' && value?.url) {
+        // Retro compatibility with old binary data structure {url: '...', mimetype: '...', url: 'http(s)://...'}
+        const binaryInput = await BinaryInput.from(value.url, '', value?.mimetype);
+        const buffer = await binaryInput.getBuffer();
+
+        return { data: buffer, headers: { 'Content-Type': binaryInput.mimetype } };
+    }
+
+    return { data: Buffer.from([]), headers: {} };
+}
+
+async function handleNone(body: any, input: any, config, agent: Agent) {
+    //FIXME: try to guess the content type from headers content-type and data
+
+    return { data: typeof body === 'string' ? body : JSON.stringify(body), headers: {} };
+}
+function handleText(body: any, input: any, config: any, agent: Agent) {
+    // Parse template and input variables
+    //prettier-ignore
+    const data = TemplateString(body)
+        .parse(config.data._templateVars) //parse Template variables first (if any)
+        .parse(input) //parse inputs
+        .clean().result; //clean up the remaining unparsed values
+
+    return { data };
+}

package/src/Components/APICall/parseHeaders.ts

@@ -1,41 +1,41 @@
-import { Agent } from '@sre/AgentManager/Agent.class';
-import { REQUEST_CONTENT_TYPES } from '@sre/constants';
-import { JSONContent } from '@sre/helpers/JsonContent.helper';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { AxiosHeaders } from 'axios';
-
-export async function parseHeaders(input, config, agent: Agent) {
-    const teamId = agent ? agent.teamId : null;
-    const templateSettings = config?.template?.settings || {};
-    const contentType = config?.data?.contentType || REQUEST_CONTENT_TYPES.none;
-    let headers = typeof config?.data?.headers == 'object' ? JSON.stringify(config?.data?.headers) : config?.data?.headers || '{}';
-
-    //parse component template vars
-    if (config.data._templateVars && templateSettings) {
-        headers = await TemplateString(headers).parseComponentTemplateVarsAsync(templateSettings).asyncResult; // replaces component template vars with their IDs (this turns the string parses into an async parser) // replaces IDs with actual values then returns parser promise
-
-        headers = await TemplateString(headers).parse(config.data._templateVars).result;
-    }
-
-    //parse vault keys
-    headers = await TemplateString(headers).parseTeamKeysAsync(teamId).asyncResult;
-
-    //parse input variables and clean up the remaining unparsed values
-    headers = TemplateString(headers).parse(input).clean().result;
-
-    //parse headers as json
-    let jsonHeaders: any = JSONContent(headers).tryParse();
-    if (typeof jsonHeaders !== 'object') {
-        jsonHeaders = { 'x-smyth-error': 'Error parsing headers' };
-    }
-
-    //normalize headers key names to lowercase
-    jsonHeaders = Object.fromEntries(Object.entries(jsonHeaders).map(([key, value]) => [key.toLowerCase(), value]));
-
-    //if headers does not contain content-type, add it
-    if (!jsonHeaders['content-type'] && contentType !== 'none') {
-        jsonHeaders['content-type'] = contentType;
-    }
-
-    return new AxiosHeaders(jsonHeaders);
-}
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { REQUEST_CONTENT_TYPES } from '@sre/constants';
+import { JSONContent } from '@sre/helpers/JsonContent.helper';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { AxiosHeaders } from 'axios';
+
+export async function parseHeaders(input, config, agent: Agent) {
+    const teamId = agent ? agent.teamId : null;
+    const templateSettings = config?.template?.settings || {};
+    const contentType = config?.data?.contentType || REQUEST_CONTENT_TYPES.none;
+    let headers = typeof config?.data?.headers == 'object' ? JSON.stringify(config?.data?.headers) : config?.data?.headers || '{}';
+
+    //parse component template vars
+    if (config.data._templateVars && templateSettings) {
+        headers = await TemplateString(headers).parseComponentTemplateVarsAsync(templateSettings).asyncResult; // replaces component template vars with their IDs (this turns the string parses into an async parser) // replaces IDs with actual values then returns parser promise
+
+        headers = await TemplateString(headers).parse(config.data._templateVars).result;
+    }
+
+    //parse vault keys
+    headers = await TemplateString(headers).parseTeamKeysAsync(teamId).asyncResult;
+
+    //parse input variables and clean up the remaining unparsed values
+    headers = TemplateString(headers).parse(input).clean().result;
+
+    //parse headers as json
+    let jsonHeaders: any = JSONContent(headers).tryParse();
+    if (typeof jsonHeaders !== 'object') {
+        jsonHeaders = { 'x-smyth-error': 'Error parsing headers' };
+    }
+
+    //normalize headers key names to lowercase
+    jsonHeaders = Object.fromEntries(Object.entries(jsonHeaders).map(([key, value]) => [key.toLowerCase(), value]));
+
+    //if headers does not contain content-type, add it
+    if (!jsonHeaders['content-type'] && contentType !== 'none') {
+        jsonHeaders['content-type'] = contentType;
+    }
+
+    return new AxiosHeaders(jsonHeaders);
+}

package/src/Components/APICall/parseProxy.ts

@@ -1,68 +1,68 @@
-import { AxiosProxyConfig } from 'axios';
-import { SocksProxyAgent } from 'socks-proxy-agent';
-
-import { Agent } from '@sre/AgentManager/Agent.class';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-
-export async function parseProxy(input, config, agent: Agent): Promise<AxiosProxyConfig | SocksProxyAgent | false> {
-    const teamId = agent ? agent.teamId : null;
-    const templateSettings = config?.template?.settings || {};
-
-    let proxy = config?.data?.proxy;
-
-    if (!proxy) {
-        return false;
-    }
-
-    proxy = decodeURIComponent(proxy); //decode the url in order to parse the template vars
-
-    //parse component template vars
-    if (config.data._templateVars && templateSettings) {
-        proxy = await TemplateString(proxy)
-            .parseComponentTemplateVarsAsync(templateSettings) // replaces component template vars with their IDs (this turns the string parses into an async parser)
-            .parse(config.data._templateVars).asyncResult; // replaces IDs with actual values then returns parser promise
-    }
-
-    //parse vault keys
-    proxy = await TemplateString(proxy).parseTeamKeysAsync(teamId).asyncResult;
-
-    //parse input variables and clean up the remaining unparsed values
-    proxy = TemplateString(proxy).parse(input).clean().result;
-
-    const proxyList = proxy.split(/\n|\\n/).filter((p) => p) || [];
-
-    const randomIdx = Math.floor(Math.random() * proxyList?.length);
-    const proxyUrl = proxyList[randomIdx]?.trim();
-
-    //URL will take care of encoding the url properly
-    const urlObj = new URL(proxyUrl);
-    const protocol = urlObj.protocol.replace(':', ''); // As urlObj.protocol is like 'http:'
-
-    let proxyConfig: AxiosProxyConfig | SocksProxyAgent;
-
-    if (urlObj.protocol.startsWith('socks')) {
-        let proxyUrlString = `${protocol}://${urlObj.hostname}:${urlObj.port}`;
-
-        if ((protocol === 'socks4' || protocol === 'socks4a') && urlObj.username) {
-            proxyUrlString = `${protocol}://${urlObj.username}@${urlObj.hostname}:${urlObj.port}`;
-        } else if (protocol === 'socks5' && urlObj.username) {
-            proxyUrlString = `${protocol}://${urlObj.username}:${urlObj.password}@${urlObj.hostname}:${urlObj.port}`;
-        }
-
-        proxyConfig = new SocksProxyAgent(proxyUrlString);
-    } else {
-        proxyConfig = {
-            protocol,
-            host: urlObj.hostname,
-            port: parseInt(urlObj.port),
-            auth: urlObj.username
-                ? {
-                      username: urlObj.username,
-                      password: urlObj.password,
-                  }
-                : undefined,
-        };
-    }
-
-    return proxyConfig;
-}
+import { AxiosProxyConfig } from 'axios';
+import { SocksProxyAgent } from 'socks-proxy-agent';
+
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+
+export async function parseProxy(input, config, agent: Agent): Promise<AxiosProxyConfig | SocksProxyAgent | false> {
+    const teamId = agent ? agent.teamId : null;
+    const templateSettings = config?.template?.settings || {};
+
+    let proxy = config?.data?.proxy;
+
+    if (!proxy) {
+        return false;
+    }
+
+    proxy = decodeURIComponent(proxy); //decode the url in order to parse the template vars
+
+    //parse component template vars
+    if (config.data._templateVars && templateSettings) {
+        proxy = await TemplateString(proxy)
+            .parseComponentTemplateVarsAsync(templateSettings) // replaces component template vars with their IDs (this turns the string parses into an async parser)
+            .parse(config.data._templateVars).asyncResult; // replaces IDs with actual values then returns parser promise
+    }
+
+    //parse vault keys
+    proxy = await TemplateString(proxy).parseTeamKeysAsync(teamId).asyncResult;
+
+    //parse input variables and clean up the remaining unparsed values
+    proxy = TemplateString(proxy).parse(input).clean().result;
+
+    const proxyList = proxy.split(/\n|\\n/).filter((p) => p) || [];
+
+    const randomIdx = Math.floor(Math.random() * proxyList?.length);
+    const proxyUrl = proxyList[randomIdx]?.trim();
+
+    //URL will take care of encoding the url properly
+    const urlObj = new URL(proxyUrl);
+    const protocol = urlObj.protocol.replace(':', ''); // As urlObj.protocol is like 'http:'
+
+    let proxyConfig: AxiosProxyConfig | SocksProxyAgent;
+
+    if (urlObj.protocol.startsWith('socks')) {
+        let proxyUrlString = `${protocol}://${urlObj.hostname}:${urlObj.port}`;
+
+        if ((protocol === 'socks4' || protocol === 'socks4a') && urlObj.username) {
+            proxyUrlString = `${protocol}://${urlObj.username}@${urlObj.hostname}:${urlObj.port}`;
+        } else if (protocol === 'socks5' && urlObj.username) {
+            proxyUrlString = `${protocol}://${urlObj.username}:${urlObj.password}@${urlObj.hostname}:${urlObj.port}`;
+        }
+
+        proxyConfig = new SocksProxyAgent(proxyUrlString);
+    } else {
+        proxyConfig = {
+            protocol,
+            host: urlObj.hostname,
+            port: parseInt(urlObj.port),
+            auth: urlObj.username
+                ? {
+                      username: urlObj.username,
+                      password: urlObj.password,
+                  }
+                : undefined,
+        };
+    }
+
+    return proxyConfig;
+}