gologin 2.2.9 → 3.0.0

package/src/utils/http.js

@@ -1,64 +1,360 @@
-import { get as _get } from 'https';
-import requests from 'requestretry';
+import { get as _get, request as httpsRequest } from 'https';
+import { request as httpRequest } from 'http';
 
 import packageJson from '../../package.json' with { type: 'json' };
+import { loadHttpsProxyAgent } from './lazy-deps.js';
 
 const { version } = packageJson;
 
 const TIMEZONE_URL = 'https://geo.myip.link';
 
-const createTimeoutPromise = (timeoutMs) => new Promise((_, reject) => {
-  setTimeout(() => {
-    reject(new Error(`Request timeout after ${timeoutMs}ms`));
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_ATTEMPTS = 1;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+
+const delay = (timeMs) => new Promise((resolve) => setTimeout(resolve, timeMs));
+
+const shouldRetryRequest = ({ error, attempt, maxAttempts }) => {
+  if (attempt >= maxAttempts) {
+    return false;
+  }
+
+  if (error.statusCode) {
+    return error.statusCode >= 500;
+  }
+
+  return true;
+};
+
+const createRequestSignal = (timeoutMs) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort(new Error(`Request timeout after ${timeoutMs}ms`));
   }, timeoutMs);
-});
 
-const attemptRequest = async (requestUrl, options) => {
-  const requestPromise = requests(requestUrl, options);
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timeoutId),
+  };
+};
 
-  let req;
-  if (options.proxy) {
-    const timeoutPromise = createTimeoutPromise(options.timeout || 30000);
-    req = await Promise.race([requestPromise, timeoutPromise]);
-  } else {
-    req = await requestPromise;
+const parseJsonBody = (text) => {
+  if (!text) {
+    return null;
   }
 
-  if (req.statusCode >= 400) {
-    const error = new Error(req.body);
-    error.statusCode = req.statusCode;
-    throw error;
+  return JSON.parse(text);
+};
+
+const readResponseBody = async (response, options) => {
+  const shouldParseJson = options.json === true || (options.json && typeof options.json === 'object');
+
+  if (shouldParseJson) {
+    const text = await response.text();
+
+    return parseJsonBody(text);
   }
 
-  return req.body;
+  return response.text();
 };
 
-export const makeRequest = async (url, options = {}, internalOptions) => {
-  options.headers = {
+const buildRequestHeaders = ({ options, internalOptions }) => {
+  const headers = {
     ...options.headers,
-    'User-Agent': `gologin-nodejs-sdk/${version}`,
+    'User-Agent': options.headers?.['User-Agent'] || `gologin-nodejs-sdk/${version}`,
   };
 
   if (internalOptions?.token) {
-    options.headers = {
-      ...options.headers,
-      Authorization: `Bearer ${internalOptions.token}`,
-    };
+    headers.Authorization = `Bearer ${internalOptions.token}`;
+  }
+
+  return headers;
+};
+
+const buildRequestBody = (options) => {
+  if (options.json !== undefined && options.json !== true) {
+    return JSON.stringify(options.json);
+  }
+
+  return options.body;
+};
+
+const buildFetchInit = ({ options, internalOptions }) => {
+  const headers = buildRequestHeaders({ options, internalOptions });
+  const body = buildRequestBody(options);
+
+  if (options.json !== undefined && options.json !== true) {
+    headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+  }
+
+  return {
+    method: options.method || 'GET',
+    headers,
+    body: body ?? undefined,
+  };
+};
+
+const parseProxyResponseBody = (text, options) => {
+  const shouldParseJson = options.json === true || (options.json && typeof options.json === 'object');
+
+  if (shouldParseJson) {
+    return parseJsonBody(text);
+  }
+
+  return text;
+};
+
+const normalizeProxyUrl = (proxyUrl) => {
+  const parsed = new URL(proxyUrl);
+
+  if (parsed.protocol === 'https:') {
+    parsed.protocol = 'http:';
+  }
+
+  return parsed.toString();
+};
+
+const executeProxyRequest = async (url, options, internalOptions) => {
+  const HttpsProxyAgent = await loadHttpsProxyAgent();
+  const agent = new HttpsProxyAgent(normalizeProxyUrl(options.proxy));
+  const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+  const headers = buildRequestHeaders({ options, internalOptions });
+  const body = buildRequestBody(options);
+  const method = options.method || 'GET';
+  const parsedUrl = new URL(url);
+  const requestFn = parsedUrl.protocol === 'http:' ? httpRequest : httpsRequest;
+
+  if (options.json !== undefined && options.json !== true) {
+    headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+  }
+
+  const requestOptions = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+    path: `${parsedUrl.pathname}${parsedUrl.search}`,
+    method,
+    headers,
+    agent,
+    timeout: timeoutMs,
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = requestFn(requestOptions, (response) => {
+      let responseText = '';
+
+      response.on('data', (chunk) => {
+        responseText += chunk;
+      });
+
+      response.on('end', () => {
+        if (response.statusCode >= 400) {
+          const error = new Error(responseText);
+          error.statusCode = response.statusCode;
+
+          reject(error);
+
+          return;
+        }
+
+        resolve(parseProxyResponseBody(responseText, options));
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy(new Error(`Request timeout after ${timeoutMs}ms`));
+    });
+
+    if (body) {
+      req.write(body);
+    }
+
+    req.end();
+  });
+};
+
+const executeFetch = async (url, options = {}, internalOptions) => {
+  if (options.proxy) {
+    const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+    const maxAttempts = options.maxAttempts || DEFAULT_MAX_ATTEMPTS;
+    const retryDelayMs = options.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+    let lastError;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await executeProxyRequest(url, options, internalOptions);
+      } catch (error) {
+        lastError = error;
+
+        if (!shouldRetryRequest({ error, attempt, maxAttempts })) {
+          throw error;
+        }
+
+        await delay(retryDelayMs);
+      }
+    }
+
+    throw lastError;
+  }
+
+  const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+  const maxAttempts = options.maxAttempts || DEFAULT_MAX_ATTEMPTS;
+  const retryDelayMs = options.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { signal, clear } = createRequestSignal(timeoutMs);
+
+    try {
+      const init = buildFetchInit({ options, internalOptions });
+      init.signal = signal;
+
+      const response = await fetch(url, init);
+      clear();
+
+      const body = await readResponseBody(response, options);
+
+      if (response.status >= 400) {
+        const errorMessage = typeof body === 'string' ? body : JSON.stringify(body);
+        const error = new Error(errorMessage);
+        error.statusCode = response.status;
+
+        throw error;
+      }
+
+      return body;
+    } catch (error) {
+      clear();
+      lastError = error;
+
+      if (!shouldRetryRequest({ error, attempt, maxAttempts })) {
+        throw error;
+      }
+
+      await delay(retryDelayMs);
+    }
   }
 
+  throw lastError;
+};
+
+export const makeRequest = async (url, options = {}, internalOptions) => {
   try {
-    return await attemptRequest(url, options);
+    return await executeFetch(url, options, internalOptions);
   } catch (error) {
     if (internalOptions?.fallbackUrl && !error.statusCode) {
-      const fallbackData = await attemptRequest(internalOptions.fallbackUrl, options);
-
-      return fallbackData;
+      return executeFetch(internalOptions.fallbackUrl, options, internalOptions);
     }
 
     throw error;
   }
 };
 
+export const fetchHeadWithRetry = async (url, options = {}) => {
+  const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+  const maxAttempts = options.maxAttempts || DEFAULT_MAX_ATTEMPTS;
+  const retryDelayMs = options.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { signal, clear } = createRequestSignal(timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        method: 'HEAD',
+        redirect: 'follow',
+        signal,
+      });
+
+      clear();
+
+      if (response.status >= 400) {
+        const error = new Error(`HEAD request failed with status ${response.status}`);
+        error.statusCode = response.status;
+
+        throw error;
+      }
+
+      const responseUrl = new URL(response.url);
+
+      return {
+        req: { path: `${responseUrl.pathname}${responseUrl.search}` },
+        statusCode: response.status,
+      };
+    } catch (error) {
+      clear();
+      lastError = error;
+
+      if (!shouldRetryRequest({ error, attempt, maxAttempts })) {
+        throw error;
+      }
+
+      await delay(retryDelayMs);
+    }
+  }
+
+  throw lastError;
+};
+
+export const fetchBufferWithRetry = async (url, options = {}) => {
+  const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+  const maxAttempts = options.maxAttempts || DEFAULT_MAX_ATTEMPTS;
+  const retryDelayMs = options.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { signal, clear } = createRequestSignal(timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        redirect: 'follow',
+        signal,
+      });
+
+      clear();
+
+      if (response.status >= 400) {
+        const error = new Error(`GET request failed with status ${response.status}`);
+        error.statusCode = response.status;
+
+        throw error;
+      }
+
+      const arrayBuffer = await response.arrayBuffer();
+
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      clear();
+      lastError = error;
+
+      if (!shouldRetryRequest({ error, attempt, maxAttempts })) {
+        throw error;
+      }
+
+      await delay(retryDelayMs);
+    }
+  }
+
+  throw lastError;
+};
+
+export const fetchToWriteStream = async (url, writeStream, options = {}) => {
+  const buffer = await fetchBufferWithRetry(url, options);
+
+  await new Promise((resolve, reject) => {
+    writeStream.write(buffer, (error) => {
+      if (error) {
+        reject(error);
+
+        return;
+      }
+
+      writeStream.end(resolve);
+    });
+  });
+};
+
 export const checkSocksProxy = async (agent) => new Promise((resolve, reject) => {
   _get(TIMEZONE_URL, { agent, timeout: 8000 }, (res) => {
     let resultResponse = '';

package/src/utils/lazy-deps.js

@@ -0,0 +1,206 @@
+const cache = {};
+
+const resolveDefault = (module) => module?.default ?? module;
+
+const resolveSocksProxyAgent = (module) => {
+  const resolved = resolveDefault(module);
+
+  return resolved.SocksProxyAgent ?? resolved;
+};
+
+const resolveHttpsProxyAgent = (module) => {
+  const resolved = resolveDefault(module);
+
+  return resolved.HttpsProxyAgent ?? resolved;
+};
+
+const importAndAssign = (key, importPromise) => importPromise.then((value) => {
+  cache[key] = value;
+
+  return value;
+});
+
+export const loadRimraf = () => {
+  if (cache.rimraf !== undefined) {
+    return Promise.resolve(cache.rimraf);
+  }
+
+  cache.rimrafPromise ||= import('rimraf').then(resolveDefault).then((value) => {
+    cache.rimraf = value;
+
+    return value;
+  });
+
+  return cache.rimrafPromise;
+};
+
+export const loadDecompress = () => {
+  if (cache.decompressReady) {
+    return Promise.resolve(cache.decompressReady);
+  }
+
+  cache.decompressPromise ||= Promise.all([
+    import('decompress').then(resolveDefault),
+    import('decompress-unzip').then(resolveDefault),
+  ]).then(([decompress, decompressUnzip]) => {
+    cache.decompressReady = { decompress, decompressUnzip };
+
+    return cache.decompressReady;
+  });
+
+  return cache.decompressPromise;
+};
+
+export const loadSocksProxyAgent = () => {
+  if (cache.socksProxyAgent !== undefined) {
+    return Promise.resolve(cache.socksProxyAgent);
+  }
+
+  cache.socksProxyAgentPromise ||= import('socks-proxy-agent').then(resolveSocksProxyAgent).then((value) => {
+    cache.socksProxyAgent = value;
+
+    return value;
+  });
+
+  return cache.socksProxyAgentPromise;
+};
+
+export const loadHttpsProxyAgent = () => {
+  if (cache.httpsProxyAgent !== undefined) {
+    return Promise.resolve(cache.httpsProxyAgent);
+  }
+
+  cache.httpsProxyAgentPromise ||= import('https-proxy-agent').then(resolveHttpsProxyAgent).then((value) => {
+    cache.httpsProxyAgent = value;
+
+    return value;
+  });
+
+  return cache.httpsProxyAgentPromise;
+};
+
+export const loadSentry = () => {
+  return Promise.resolve(null);
+
+  // cache.sentry ||= import('@sentry/node');
+  //
+  // return cache.sentry;
+};
+
+export const loadCookiesManager = () => {
+  if (cache.cookiesManager) {
+    return Promise.resolve(cache.cookiesManager);
+  }
+
+  cache.cookiesManagerPromise ||= import('../cookies/cookies-manager.js').then((value) => {
+    cache.cookiesManager = value;
+
+    return value;
+  });
+
+  return cache.cookiesManagerPromise;
+};
+
+export const loadProfileArchiver = () => {
+  cache.profileArchiver ||= import('../profile/profile-archiver.js');
+
+  return cache.profileArchiver;
+};
+
+export const loadExtensionsManager = () => {
+  if (cache.extensionsManagerClass !== undefined) {
+    return Promise.resolve(cache.extensionsManagerClass);
+  }
+
+  cache.extensionsManagerPromise ||= import('../extensions/extensions-manager.js').then(resolveDefault).then((value) => {
+    cache.extensionsManagerClass = value;
+
+    return value;
+  });
+
+  return cache.extensionsManagerPromise;
+};
+
+export const loadBrowserChecker = () => {
+  if (cache.browserCheckerClass !== undefined) {
+    return Promise.resolve(cache.browserCheckerClass);
+  }
+
+  cache.browserCheckerPromise ||= import('../browser/browser-checker.js').then(resolveDefault).then((value) => {
+    cache.browserCheckerClass = value;
+
+    return value;
+  });
+
+  return cache.browserCheckerPromise;
+};
+
+export const preloadStartupDeps = () => {
+  if (cache.startupPreload) {
+    return cache.startupPreload;
+  }
+
+  cache.startupPreload = Promise.all([
+    importAndAssign('rimraf', import('rimraf').then(resolveDefault)),
+    importAndAssign('decompressLib', import('decompress').then(resolveDefault)),
+    importAndAssign('decompressUnzipLib', import('decompress-unzip').then(resolveDefault)),
+    importAndAssign('socksProxyAgent', import('socks-proxy-agent').then(resolveSocksProxyAgent)),
+    importAndAssign('cookiesManager', import('../cookies/cookies-manager.js')),
+    importAndAssign('extensionsManagerClass', import('../extensions/extensions-manager.js').then(resolveDefault)),
+  ]).then(() => {
+    cache.decompressReady = {
+      decompress: cache.decompressLib,
+      decompressUnzip: cache.decompressUnzipLib,
+    };
+  });
+
+  return cache.startupPreload;
+};
+
+export const ensureSentryInitialized = async (_options = {}) => {
+  return null;
+
+  // if (process.env.DISABLE_TELEMETRY === 'true') {
+  //   return null;
+  // }
+  //
+  // if (cache.sentryInitialized) {
+  //   return cache.sentryModule;
+  // }
+  //
+  // const Sentry = await loadSentry();
+  // Sentry.init({
+  //   dsn: 'https://a13d5939a60ae4f6583e228597f1f2a0@sentry-new.amzn.pro/24',
+  //   tracesSampleRate: 1.0,
+  //   defaultIntegrations: false,
+  //   release: release || '2.1.34',
+  // });
+  // cache.sentryInitialized = true;
+  // cache.sentryModule = Sentry;
+  //
+  // return Sentry;
+};
+
+export const removePath = async (targetPath, options) => {
+  const rimrafFn = await loadRimraf();
+
+  return new Promise((resolve, reject) => {
+    const onComplete = (error) => {
+      if (error) {
+        reject(error);
+
+        return;
+      }
+
+      resolve();
+    };
+
+    if (options && typeof options === 'object') {
+      rimrafFn(targetPath, options, onComplete);
+
+      return;
+    }
+
+    rimrafFn(targetPath, onComplete);
+  });
+};

package/src/utils/sentry.js

@@ -1,6 +1,11 @@
-import * as Sentry from '@sentry/node';
+// import { loadSentry } from './lazy-deps.js';
 
-export const captureGroupedSentryError = (error, context = {}) => {
+export const captureGroupedSentryError = async (_error, _context = {}) => {
+  return;
+};
+
+/*
+export const captureGroupedSentryError = async (error, context = {}) => {
   if (process.env.DISABLE_TELEMETRY === 'true') {
     return;
   }
@@ -61,6 +66,7 @@ export const captureGroupedSentryError = (error, context = {}) => {
       break;
   }
 
+  const Sentry = await loadSentry();
   Sentry.captureException(error, scope => {
     scope.setFingerprint(fingerprint);
     scope.setTransactionName(fingerprint);
@@ -71,3 +77,4 @@ export const captureGroupedSentryError = (error, context = {}) => {
     });
   });
 };
+*/