gologin 2.2.8 → 3.0.0

package/src/gologin.js

@@ -1,39 +1,32 @@
-import * as Sentry from '@sentry/node';
 import { execFile, spawn } from 'child_process';
 import debugDefault from 'debug';
-import decompress from 'decompress';
-import decompressUnzip from 'decompress-unzip';
 import { existsSync, mkdirSync, promises as _promises } from 'fs';
 import { tmpdir } from 'os';
 import { join, resolve as _resolve, sep } from 'path';
-import rimraf from 'rimraf';
-import { SocksProxyAgent } from 'socks-proxy-agent';
 
-import { fontsCollection } from '../fonts.js';
 import { getCurrentProfileBookmarks } from './bookmarks/utils.js';
 import { updateProfileBookmarks, updateProfileProxy, updateProfileResolution, updateProfileUserAgent } from './browser/browser-api.js';
-import BrowserChecker from './browser/browser-checker.js';
 import {
-  composeFonts, downloadCookies, setExtPathsAndRemoveDeleted, setOriginalExtPaths, uploadCookies,
+  downloadCookies, setExtPathsAndRemoveDeleted, setOriginalExtPaths, uploadCookies,
 } from './browser/browser-user-data-manager.js';
-import {
-  createDBFile,
-  getChunckedInsertValues,
-  getCookiesFilePath,
-  getDB,
-  getUniqueCookies,
-  loadCookiesFromFile,
-} from './cookies/cookies-manager.js';
-import ExtensionsManager from './extensions/extensions-manager.js';
-import { archiveProfile } from './profile/profile-archiver.js';
+import { getProfileChromeExtensions } from './extensions/get-extensions.js';
 import { checkAutoLang, getIntlProfileConfig, securedOrbitaOpts } from './utils/browser.js';
 import { API_URL, ensureDirectoryExists, FALLBACK_API_URL, getOsAdvanced } from './utils/common.js';
 import { STORAGE_GATEWAY_BASE_URL } from './utils/constants.js';
-import { get, isPortReachable } from './utils/utils.js';
-export { exitAll, GologinApi } from './gologin-api.js';
-import { getProfileChromeExtensions } from './extensions/get-extensions.js';
 import { checkSocksProxy, makeRequest } from './utils/http.js';
-import { captureGroupedSentryError } from './utils/sentry.js';
+import {
+  // ensureSentryInitialized,
+  loadBrowserChecker,
+  loadCookiesManager,
+  loadDecompress,
+  loadExtensionsManager,
+  loadProfileArchiver,
+  loadSocksProxyAgent,
+  preloadStartupDeps,
+  removePath,
+} from './utils/lazy-deps.js';
+import { get, isPortReachable } from './utils/utils.js';
+// import { captureGroupedSentryError } from './utils/sentry.js';
 import { zeroProfileBookmarks } from './utils/zero-profile-bookmarks.js';
 import { zeroProfilePreferences } from './utils/zero-profile-preferences.js';
 
@@ -70,7 +63,8 @@ export class GoLogin {
     this.tmpdir = tmpdir();
     this.autoUpdateBrowser = !!options.autoUpdateBrowser;
     this.checkBrowserUpdate = options.checkBrowserUpdate ?? true;
-    this.browserChecker = new BrowserChecker(options.skipOrbitaHashChecking);
+    this._skipOrbitaHashChecking = options.skipOrbitaHashChecking;
+    this._browserChecker = null;
     this.uploadCookiesToServer = options.uploadCookiesToServer || false;
     this.writeCookiesFromServer = options.writeCookiesFromServer ?? true;
     this.remote_debugging_port = options.remote_debugging_port || 0;
@@ -85,15 +79,6 @@ export class GoLogin {
     this.proxyCheckTimeout = options.proxyCheckTimeout || 13 * 1000;
     this.proxyCheckAttempts = options.proxyCheckAttempts || 3;
 
-    if (process.env.DISABLE_TELEMETRY !== 'true') {
-      Sentry.init({
-        dsn: 'https://a13d5939a60ae4f6583e228597f1f2a0@sentry-new.amzn.pro/24',
-        tracesSampleRate: 1.0,
-        defaultIntegrations: false,
-        release: process.env.npm_package_version || '2.1.34',
-      });
-    }
-
     if (options.tmpdir) {
       this.tmpdir = options.tmpdir;
       if (!existsSync(this.tmpdir)) {
@@ -107,8 +92,18 @@ export class GoLogin {
     debug('INIT GOLOGIN', this.profile_id);
   }
 
+  async getBrowserChecker() {
+    if (!this._browserChecker) {
+      const BrowserChecker = await loadBrowserChecker();
+      this._browserChecker = new BrowserChecker(this._skipOrbitaHashChecking);
+    }
+
+    return this._browserChecker;
+  }
+
   async checkBrowser(majorVersion) {
-    this.executablePath = await this.browserChecker.checkBrowser({
+    const browserChecker = await this.getBrowserChecker();
+    this.executablePath = await browserChecker.checkBrowser({
       autoUpdateBrowser: this.autoUpdateBrowser,
       checkBrowserUpdate: this.checkBrowserUpdate,
       majorVersion,
@@ -130,7 +125,8 @@ export class GoLogin {
     }
 
     for (const majorVersion of versionsToDownload) {
-      await this.browserChecker.checkBrowser({
+      const browserChecker = await this.getBrowserChecker();
+      await browserChecker.checkBrowser({
         autoUpdateBrowser: true,
         checkBrowserUpdate: true,
         majorVersion,
@@ -141,7 +137,8 @@ export class GoLogin {
   }
 
   async getLatestBrowserVersion() {
-    const { latestVersion: browserLatestVersion } = await this.browserChecker.getLatestBrowserVersion();
+    const browserChecker = await this.getBrowserChecker();
+    const { latestVersion: browserLatestVersion } = await browserChecker.getLatestBrowserVersion();
     const [latestBrowserMajorVersion] = browserLatestVersion.split('.');
 
     return Number(latestBrowserMajorVersion);
@@ -149,6 +146,7 @@ export class GoLogin {
 
   async setProfileId(profile_id) {
     this.profile_id = profile_id;
+    const { getCookiesFilePath } = await loadCookiesManager();
     this.cookiesFilePath = await getCookiesFilePath(profile_id, this.tmpdir);
     this.profile_zip_path = join(this.tmpdir, `gologin_${this.profile_id}.zip`);
     this.bookmarksFilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`, 'Default', 'Bookmarks');
@@ -359,10 +357,11 @@ export class GoLogin {
   async createBrowserExtension() {
     const that = this;
     debug('start createBrowserExtension');
-    await rimraf(this.orbitaExtensionPath(), () => null);
+    await removePath(this.orbitaExtensionPath());
     const extPath = this.orbitaExtensionPath();
     debug('extension folder sanitized');
     const extension_source = _resolve(__dirname, 'gologin-browser-ext.zip');
+    const { decompress, decompressUnzip } = await loadDecompress();
     await decompress(extension_source, extPath,
       {
         plugins: [decompressUnzip()],
@@ -383,8 +382,9 @@ export class GoLogin {
     debug('createBrowserExtension done');
   }
 
-  extractProfile(path, zipfile) {
+  async extractProfile(path, zipfile) {
     debug(`extactProfile ${zipfile}, ${path}`);
+    const { decompress, decompressUnzip } = await loadDecompress();
 
     return decompress(zipfile, path,
       {
@@ -397,19 +397,24 @@ export class GoLogin {
   async downloadProfileAndExtract(profile, local) {
     let profile_folder;
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
+
     const profileZipExists = await access(this.profile_zip_path).then(() => true).catch(() => false);
 
     if (!(local && profileZipExists)) {
       try {
-        profile_folder = await this.getProfileS3();
+        const [, profileData] = await Promise.all([
+          loadDecompress(),
+          this.getProfileS3(),
+        ]);
+
+        profile_folder = profileData;
       } catch (e) {
         debug('Cannot get profile - using empty', e);
+        await loadDecompress();
       }
 
       debug('FILE READY', this.profile_zip_path);
-
       await writeFile(this.profile_zip_path, profile_folder);
-
       debug('PROFILE LENGTH', profile_folder.length);
     } else {
       debug('PROFILE LOCAL HAVING', this.profile_zip_path);
@@ -435,6 +440,7 @@ export class GoLogin {
   }
 
   async createZeroProfile(createCookiesTableQuery) {
+    const { createDBFile } = await loadCookiesManager();
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
     const defaultFilePath = _resolve(profilePath, 'Default');
     const preferencesFilePath = _resolve(defaultFilePath, 'Preferences');
@@ -457,47 +463,16 @@ export class GoLogin {
 
   async createStartup(local = false) {
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
-    await rimraf(profilePath, () => null);
-    debug('-', profilePath, 'dropped');
-    const profile = await this.getProfile();
-    if (!profile) {
-      throw new Error('Error fetching profile data');
-    }
+    const startupDepsPromise = preloadStartupDeps();
 
-    if (!this.executablePath) {
-      const { userAgent } = profile.navigator;
-      try {
-        const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
-        this.browserMajorVersion = Number(browserMajorVersion);
-        await this.checkBrowser(browserMajorVersion);
-      } catch (e) {
-        const latestVersionNumber = await this.getLatestBrowserVersion();
-        this.browserMajorVersion = latestVersionNumber;
-        await this.checkBrowser(latestVersionNumber);
-      }
-    } else if (!this.browserMajorVersion) {
-      const { userAgent } = profile.navigator;
-      const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
-      this.browserMajorVersion = Number(browserMajorVersion);
-
-      let executableDir = join(this.executablePath, '..');
-      if (OS_PLATFORM === 'darwin') {
-        executableDir = join(this.executablePath, '..', '..', '..');
-      }
+    const [profile] = await Promise.all([
+      this.getProfile(),
+      startupDepsPromise.then(() => removePath(profilePath)
+        .then(() => debug('-', profilePath, 'dropped'))),
+    ]);
 
-      const versionFilePath = join(executableDir, 'version');
-      try {
-        await access(versionFilePath);
-        const versionContent = await readFile(versionFilePath, 'utf8');
-        const versionFromFile = versionContent.trim();
-        const isValidVersion = /^\d+\.\d+\.\d+/.test(versionFromFile);
-        if (isValidVersion) {
-          const [browserMajorVersion] = isValidVersion.split('.');
-          this.browserMajorVersion = Number(browserMajorVersion);
-        }
-      } catch (error) {
-        console.warn('Error reading version file:', error);
-      }
+    if (!profile) {
+      throw new Error('Error fetching profile data');
     }
 
     const { navigator = {}, fonts, os: profileOs } = profile;
@@ -510,10 +485,7 @@ export class GoLogin {
         OS_PLATFORM === 'linux' && profileOs !== 'lin'
       );
 
-    const {
-      resolution = '1920x1080',
-    } = navigator;
-
+    const { resolution = '1920x1080' } = navigator;
     const [screenWidth, screenHeight] = resolution.split('x');
     this.resolution = {
       width: parseInt(screenWidth, 10),
@@ -521,87 +493,8 @@ export class GoLogin {
     };
 
     this.createCookiesTableQuery = profile.createCookiesTableQuery;
-    if (profile.storageInfo.isNewProfile) {
-      this.isFirstSession = true;
-      await this.createZeroProfile(profile.createCookiesTableQuery);
-    } else {
-      this.isFirstSession = false;
-      await this.downloadProfileAndExtract(profile, local);
-    }
-
-    await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
-    const pref_file_name = join(profilePath, 'Default', 'Preferences');
-    debug('reading', pref_file_name);
-
-    const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
-    if (!prefFileExists) {
-      debug('Preferences file not exists waiting', pref_file_name, '. Using empty profile');
-      await mkdir(join(profilePath, 'Default'), { recursive: true });
-      await writeFile(pref_file_name, '{}');
-    }
 
-    const preferences_raw = await readFile(pref_file_name);
-    const preferences = JSON.parse(preferences_raw.toString());
     let proxy = get(profile, 'proxy');
-    const chromeExtensions = get(profile, 'chromeExtensions') || [];
-    const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
-    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
-
-    if (allExtensions.length) {
-      const ExtensionsManagerInst = new ExtensionsManager();
-      ExtensionsManagerInst.apiUrl = API_URL;
-      await ExtensionsManagerInst.init()
-        .then(() => ExtensionsManagerInst.updateExtensions())
-        .catch(() => {});
-      ExtensionsManagerInst.accessToken = this.access_token;
-
-      await ExtensionsManagerInst.getExtensionsPolicies();
-      let profileExtensionsCheckRes = [];
-
-      if (ExtensionsManagerInst.useLocalExtStorage) {
-        const promises = [
-          ExtensionsManagerInst.checkChromeExtensions(allExtensions)
-            .then(res => ({ profileExtensionsCheckRes: res }))
-            .catch((e) => {
-              console.log('checkChromeExtensions error: ', e);
-
-              return { profileExtensionsCheckRes: [] };
-            }),
-          ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions, this.profile_id)
-            .then(res => ({ profileUserExtensionsCheckRes: res }))
-            .catch((error) => {
-              console.log('checkUserChromeExtensions error: ', error);
-
-              return null;
-            }),
-        ];
-
-        const extensionsResult = await Promise.all(promises);
-
-        const profileExtensionPathRes = extensionsResult.find(el => 'profileExtensionsCheckRes' in el) || {};
-        const profileUserExtensionPathRes = extensionsResult.find(el => 'profileUserExtensionsCheckRes' in el);
-        profileExtensionsCheckRes =
-          (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []);
-      }
-
-      let extSettings;
-      if (ExtensionsManagerInst.useLocalExtStorage) {
-        extSettings = await setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes, this.profile_id);
-      } else {
-        const originalExtensionsFolder = join(profilePath, 'Default', 'Extensions');
-        extSettings = await setOriginalExtPaths(preferences, originalExtensionsFolder);
-      }
-
-      this.extensionPathsToInstall =
-        ExtensionsManagerInst.getExtensionsToInstall(extSettings, profileExtensionsCheckRes);
-
-      if (extSettings) {
-        const currentExtSettings = preferences.extensions || {};
-        currentExtSettings.settings = extSettings;
-        preferences.extensions = currentExtSettings;
-      }
-    }
-
     if (proxy.mode === 'gologin' || proxy.mode === 'tor') {
       const autoProxyServer = get(profile, 'autoProxyServer');
       const splittedAutoProxyServer = autoProxyServer.split('://');
@@ -630,51 +523,62 @@ export class GoLogin {
 
     this.proxy = proxy;
 
-    await this.getTimeZone(proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
-      throw new Error(`Proxy Error. ${e.message}`);
-    });
-
-    const gologin = this.getGologinPreferences(profile);
+    await Promise.all([
+      this.resolveProfileBrowserVersion(profile),
+      this.initProfileStorage({ profile, local }),
+      this.getTimeZone(proxy).catch((e) => {
+        console.error('Proxy Error. Check it and try again.');
+        throw new Error(`Proxy Error. ${e.message}`);
+      }),
+      this.initCookiesFile(profile),
+    ]);
 
-    debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
-    gologin.screenWidth = this.resolution.width;
-    gologin.screenHeight = this.resolution.height;
-    debug('writeCookiesFromServer', this.writeCookiesFromServer);
-    this.cookiesFilePath = await getCookiesFilePath(this.profile_id, this.tmpdir);
+    await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
+    const pref_file_name = join(profilePath, 'Default', 'Preferences');
+    debug('reading', pref_file_name);
 
-    if (this.writeCookiesFromServer) {
-      await this.writeCookiesToFile(profile.cookies?.cookies);
+    const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
+    if (!prefFileExists) {
+      debug('Preferences file not exists waiting', pref_file_name, '. Using empty profile');
+      await mkdir(join(profilePath, 'Default'), { recursive: true });
+      await writeFile(pref_file_name, '{}');
     }
 
+    const preferences_raw = await readFile(pref_file_name);
+    const preferences = JSON.parse(preferences_raw.toString());
+    const chromeExtensions = get(profile, 'chromeExtensions') || [];
+    const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
+    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
+
+    const [, orbitaParamsToken] = await Promise.all([
+      this.setupProfileExtensions({
+        preferences, allExtensions, userChromeExtensions, profilePath,
+      }),
+      this.fetchOrbitaParamsToken(profile),
+    ]);
+
     if (this.fontsMasking) {
       const families = fonts?.families || [];
       if (!families.length) {
         this.isEmptyFonts = true;
       }
-
-      try {
-        await composeFonts(families, profilePath, this.differentOs);
-      } catch (e) {
-        console.trace(e);
-      }
     }
 
     if (preferences.gologin === null) {
       preferences.gologin = {};
     }
 
+    const gologin = this.getGologinPreferences(profile);
+
+    debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
+    gologin.screenWidth = this.resolution.width;
+    gologin.screenHeight = this.resolution.height;
+    debug('writeCookiesFromServer', this.writeCookiesFromServer);
+
     const isMAC = OS_PLATFORM === 'darwin';
     const checkAutoLangResult = checkAutoLang(gologin, this._tz, profile.autoLang);
     const intlConfig = getIntlProfileConfig(profile, this._tz, profile.autoLang);
 
-    let orbitaParamsToken = '';
-    if (profile.securedOrbitaVersion && (this.browserMajorVersion >= profile.securedOrbitaVersion)) {
-      const tokenRes = await this.requestOrbitaProfileParamsToken(this.profile_id);
-
-      orbitaParamsToken = tokenRes.token;
-    }
-
     this.browserLang = isMAC ? 'en-US' : checkAutoLangResult;
     const prefsToWrite = Object.assign(preferences, { gologin });
     if (this.browserMajorVersion >= this.newProxyOrbitaMajorVersion && this.proxy?.mode !== 'none') {
@@ -701,12 +605,143 @@ export class GoLogin {
     const bookmarksFromDb = profile.bookmarks?.bookmark_bar;
     bookmarksParsedData.roots = bookmarksFromDb ? profile.bookmarks : bookmarksParsedData.roots;
     await writeFile(this.bookmarksFilePath, JSON.stringify(bookmarksParsedData));
-
     debug('Profile ready. Path: ', profilePath, 'PROXY', JSON.stringify(get(preferences, 'gologin.proxy')));
 
     return profilePath;
   }
 
+  async resolveProfileBrowserVersion(profile) {
+    if (!this.executablePath) {
+      const { userAgent } = profile.navigator;
+      try {
+        const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
+        this.browserMajorVersion = Number(browserMajorVersion);
+        await this.checkBrowser(browserMajorVersion);
+      } catch (e) {
+        const latestVersionNumber = await this.getLatestBrowserVersion();
+        this.browserMajorVersion = latestVersionNumber;
+        await this.checkBrowser(latestVersionNumber);
+      }
+
+      return;
+    }
+
+    if (!this.browserMajorVersion) {
+      const { userAgent } = profile.navigator;
+      const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
+      this.browserMajorVersion = Number(browserMajorVersion);
+
+      let executableDir = join(this.executablePath, '..');
+      if (OS_PLATFORM === 'darwin') {
+        executableDir = join(this.executablePath, '..', '..', '..');
+      }
+
+      const versionFilePath = join(executableDir, 'version');
+      try {
+        await access(versionFilePath);
+        const versionContent = await readFile(versionFilePath, 'utf8');
+        const versionFromFile = versionContent.trim();
+        const isValidVersion = /^\d+\.\d+\.\d+/.test(versionFromFile);
+        if (isValidVersion) {
+          const [browserMajorVersion] = isValidVersion.split('.');
+          this.browserMajorVersion = Number(browserMajorVersion);
+        }
+      } catch (error) {
+        console.warn('Error reading version file:', error);
+      }
+    }
+  }
+
+  async initProfileStorage({ profile, local }) {
+    if (profile.storageInfo.isNewProfile) {
+      this.isFirstSession = true;
+      await this.createZeroProfile(profile.createCookiesTableQuery);
+
+      return;
+    }
+
+    this.isFirstSession = false;
+    await this.downloadProfileAndExtract(profile, local);
+  }
+
+  async initCookiesFile(profile) {
+    const { getCookiesFilePath } = await loadCookiesManager();
+    this.cookiesFilePath = await getCookiesFilePath(this.profile_id, this.tmpdir);
+    if (this.writeCookiesFromServer) {
+      await this.writeCookiesToFile(profile.cookies?.cookies);
+    }
+  }
+
+  async setupProfileExtensions({ preferences, allExtensions, userChromeExtensions, profilePath }) {
+    if (!allExtensions.length) {
+      return;
+    }
+
+    const ExtensionsManager = await loadExtensionsManager();
+    const ExtensionsManagerInst = new ExtensionsManager();
+    ExtensionsManagerInst.apiUrl = API_URL;
+    await ExtensionsManagerInst.init()
+      .then(() => ExtensionsManagerInst.updateExtensions())
+      .catch(() => {});
+    ExtensionsManagerInst.accessToken = this.access_token;
+
+    await ExtensionsManagerInst.getExtensionsPolicies();
+    let profileExtensionsCheckRes = [];
+
+    if (ExtensionsManagerInst.useLocalExtStorage) {
+      const promises = [
+        ExtensionsManagerInst.checkChromeExtensions(allExtensions)
+          .then(res => ({ profileExtensionsCheckRes: res }))
+          .catch((e) => {
+            console.log('checkChromeExtensions error: ', e);
+
+            return { profileExtensionsCheckRes: [] };
+          }),
+        ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions, this.profile_id)
+          .then(res => ({ profileUserExtensionsCheckRes: res }))
+          .catch((error) => {
+            console.log('checkUserChromeExtensions error: ', error);
+
+            return null;
+          }),
+      ];
+
+      const extensionsResult = await Promise.all(promises);
+
+      const profileExtensionPathRes = extensionsResult.find(el => 'profileExtensionsCheckRes' in el) || {};
+      const profileUserExtensionPathRes = extensionsResult.find(el => 'profileUserExtensionsCheckRes' in el);
+      profileExtensionsCheckRes =
+        (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []);
+    }
+
+    let extSettings;
+    if (ExtensionsManagerInst.useLocalExtStorage) {
+      extSettings = await setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes, this.profile_id);
+    } else {
+      const originalExtensionsFolder = join(profilePath, 'Default', 'Extensions');
+      extSettings = await setOriginalExtPaths(preferences, originalExtensionsFolder);
+    }
+
+    this.extensionPathsToInstall =
+      ExtensionsManagerInst.getExtensionsToInstall(extSettings, profileExtensionsCheckRes);
+
+    if (extSettings) {
+      const currentExtSettings = preferences.extensions || {};
+      currentExtSettings.settings = extSettings;
+      preferences.extensions = currentExtSettings;
+    }
+  }
+
+  async fetchOrbitaParamsToken(profile) {
+    if (!profile.securedOrbitaVersion || this.browserMajorVersion < profile.securedOrbitaVersion) {
+      return '';
+    }
+
+    const tokenRes = await this.requestOrbitaProfileParamsToken(this.profile_id);
+
+    return tokenRes.token;
+  }
+
   async commitProfile() {
     // wait for orbita to finish working with files
     await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -783,6 +818,14 @@ export class GoLogin {
       return this._tz.timezone;
     }
 
+    if (this._tz) {
+      debug('getTimeZone from cache', this._tz.timezone);
+
+      return this._tz.timezone;
+    }
+
+    const isGologinProxy = proxy?.host?.includes('floppydata.com');
+
     let data = null;
     if (proxy && proxy.mode !== PROXY_NONE) {
       if (proxy.mode.includes('socks')) {
@@ -795,7 +838,7 @@ export class GoLogin {
             console.log(e.message);
           }
         }
-        throw new Error('Socks proxy connection timed out');
+        throw new Error(`Proxy Error${isGologinProxy ? ' (Gologin)' : ''}`);
       }
 
       const proxyUrl = `${proxy.mode}://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`;
@@ -806,6 +849,8 @@ export class GoLogin {
         timeout: this.proxyCheckTimeout,
         maxAttempts: this.proxyCheckAttempts,
         method: 'GET',
+      }).catch((e) => {
+        throw new Error(`${e.message}${isGologinProxy ? ' (Gologin)' : ''}`);
       });
     } else {
       data = await makeRequest(TIMEZONE_URL, { timeout: this.proxyCheckTimeout, maxAttempts: this.proxyCheckAttempts, method: 'GET' });
@@ -849,9 +894,12 @@ export class GoLogin {
     }
 
     proxy += host + ':' + port;
+    const SocksProxyAgent = await loadSocksProxyAgent();
     const agent = new SocksProxyAgent(proxy);
 
-    const checkData = await checkSocksProxy(agent);
+    const checkData = await checkSocksProxy(agent).catch((e) => {
+      throw new Error(`Proxy Error. ${e.message}`);
+    });
 
     const body = checkData.body || {};
     if (!body.ip && checkData.statusCode.toString().startsWith('4')) {
@@ -933,8 +981,14 @@ export class GoLogin {
 
     this.port = remote_debugging_port;
 
-    const ORBITA_BROWSER = this.executablePath || this.browserChecker.getOrbitaPath;
+    let ORBITA_BROWSER = this.executablePath;
+    if (!ORBITA_BROWSER) {
+      const browserChecker = await this.getBrowserChecker();
+      ORBITA_BROWSER = browserChecker.getOrbitaPath;
+    }
+
     debug(`ORBITA_BROWSER=${ORBITA_BROWSER}`);
+
     const env = {};
     Object.keys(process.env).forEach((key) => {
       env[key] = process.env[key];
@@ -1025,7 +1079,7 @@ export class GoLogin {
       debug('GETTING WS URL FROM BROWSER');
       const data = await makeRequest(
         `http://127.0.0.1:${remote_debugging_port}/json/version`,
-        { json: true, maxAttempts: 30, retryDelay: 1000, method: 'GET' },
+        { json: true, maxAttempts: 60, retryDelay: 100, method: 'GET' },
       );
 
       debug('WS IS', get(data, 'webSocketDebuggerUrl', ''));
@@ -1038,8 +1092,8 @@ export class GoLogin {
   }
 
   async clearProfileFiles() {
-    await rimraf(join(this.tmpdir, `gologin_profile_${this.profile_id}`), () => null);
-    await rimraf(join(this.tmpdir, `gologin_${this.profile_id}_upload.zip`), () => null);
+    await removePath(join(this.tmpdir, `gologin_profile_${this.profile_id}`));
+    await removePath(join(this.tmpdir, `gologin_${this.profile_id}_upload.zip`));
   }
 
   async stopAndCommit(options, local = false) {
@@ -1069,7 +1123,7 @@ export class GoLogin {
     await this.clearProfileFiles();
 
     if (!local) {
-      await rimraf(join(this.tmpdir, `gologin_${this.profile_id}.zip`), () => null);
+      await removePath(join(this.tmpdir, `gologin_${this.profile_id}.zip`));
     }
 
     debug(`PROFILE ${this.profile_id} STOPPED AND CLEAR`);
@@ -1078,6 +1132,7 @@ export class GoLogin {
   }
 
   async uploadProfileDataToServer() {
+    const { loadCookiesFromFile } = await loadCookiesManager();
     const cookies = await loadCookiesFromFile(this.cookiesFilePath, false, this.profile_id, this.tmpdir);
     const bookmarks = await getCurrentProfileBookmarks(this.bookmarksFilePath);
     const profilePreferencesPath = join(this.profilePath(), 'Default', 'Preferences');
@@ -1136,7 +1191,7 @@ export class GoLogin {
       debug('browser killed');
     } catch (error) {
       console.error(error);
-      captureGroupedSentryError(error, { method: 'killBrowser', profileId: this.profile_id });
+      // captureGroupedSentryError(error, { method: 'killBrowser', profileId: this.profile_id });
     }
   }
 
@@ -1177,13 +1232,7 @@ export class GoLogin {
     await Promise.all(remove_dirs.map(d => {
       const path_to_remove = `${that.profilePath()}${d}`;
 
-      return new Promise(resolve => {
-        debug('DROPPING', path_to_remove);
-        rimraf(path_to_remove, { maxBusyTries: 100 }, (e) => {
-          // debug('DROPPING RESULT', e);
-          resolve();
-        });
-      });
+      return removePath(path_to_remove, { maxBusyTries: 100 });
     }));
   }
 
@@ -1198,6 +1247,7 @@ export class GoLogin {
     debug('profile sanitized');
 
     const profilePath = this.profilePath();
+    const { archiveProfile } = await loadProfileArchiver();
     const fileBuff = await archiveProfile(profilePath);
 
     debug('PROFILE ZIP CREATED', profilePath, zipPath);
@@ -1387,6 +1437,13 @@ export class GoLogin {
       return;
     }
 
+    const {
+      createDBFile,
+      getChunckedInsertValues,
+      getDB,
+      getUniqueCookies,
+    } = await loadCookiesManager();
+
     const resultCookies = cookies.map((el) => ({ ...el, value: Buffer.from(el.value) }));
     let db;
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
@@ -1419,7 +1476,7 @@ export class GoLogin {
       }
 
       console.error(error.message);
-      captureGroupedSentryError(error, { method: 'writeCookiesToFile', profileId: this.profile_id });
+      // captureGroupedSentryError(error, { method: 'writeCookiesToFile', profileId: this.profile_id });
     } finally {
       db && await db.close();
       await ensureDirectoryExists(cookiesPaths.primary);
@@ -1437,20 +1494,22 @@ export class GoLogin {
   }
 
   async start() {
-    try {
-      await this.createStartup();
-      const startResponse = await this.spawnBrowser();
-      this.setActive(true);
+    // ensureSentryInitialized({ release: process.env.npm_package_version || '2.1.34' });
 
-      return { status: 'success', wsUrl: startResponse.wsUrl, resolution: startResponse.resolution };
-    } catch (error) {
-      captureGroupedSentryError(error, { method: 'start', profileId: this.profile_id });
-      throw error;
-    }
+    await this.createStartup();
+    const startResponse = await this.spawnBrowser();
+    this.setActive(true);
+
+    return {
+      status: 'success',
+      wsUrl: startResponse.wsUrl,
+      resolution: startResponse.resolution,
+    };
   }
 
   async startLocal() {
     await this.createStartup(true);
+
     // await this.createBrowserExtension();
     const startResponse = await this.spawnBrowser();
     this.setActive(true);
@@ -1525,12 +1584,6 @@ export class GoLogin {
     return updateProfileResolution(this.profile_id, this.access_token, resolution);
   }
 
-  getAvailableFonts() {
-    return fontsCollection
-      .filter(elem => elem.fileNames)
-      .map(elem => elem.name);
-  }
-
   async quickCreateProfile(name = '') {
     const osInfo = await getOsAdvanced();
     const { os, osSpec } = osInfo;