gologin-commonjs 2.1.13 → 3.0.0

package/gologin/src/gologin.js

@@ -1,22 +1,32 @@
-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 { get as _get } from 'https';
-import { tmpdir } from 'os';
-import { dirname, join, resolve as _resolve, sep } from 'path';
-import requests from 'requestretry';
-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 { 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 { get as _get } from "https";
+import { tmpdir } from "os";
+import { dirname, join, resolve as _resolve, sep } from "path";
+import requests from "requestretry";
+import rimraf from "rimraf";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { fileURLToPath } from "url";
+
+import { fontsCollection } from "../fonts.js";
+import { getCurrentProfileBookmarks } from "./bookmarks/utils.js";
 import {
-  composeFonts, downloadCookies, setExtPathsAndRemoveDeleted, setOriginalExtPaths, uploadCookies,
-} from './browser/browser-user-data-manager.js';
+  updateProfileBookmarks,
+  updateProfileProxy,
+  updateProfileResolution,
+  updateProfileUserAgent,
+} from "./browser/browser-api.js";
+import BrowserChecker from "./browser/browser-checker.js";
+import {
+  composeFonts,
+  downloadCookies,
+  setExtPathsAndRemoveDeleted,
+  setOriginalExtPaths,
+  uploadCookies,
+} from "./browser/browser-user-data-manager.js";
 import {
   createDBFile,
   getChunckedInsertValues,
@@ -24,29 +34,31 @@ import {
   getDB,
   getUniqueCookies,
   loadCookiesFromFile,
-} from './cookies/cookies-manager.js';
-import ExtensionsManager from './extensions/extensions-manager.js';
-import { archiveProfile } from './profile/profile-archiver.js';
-import { checkAutoLang } from './utils/browser.js';
-import { 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 { zeroProfileBookmarks } from './utils/zero-profile-bookmarks.js';
-import { zeroProfilePreferences } from './utils/zero-profile-preferences.js';
+} from "./cookies/cookies-manager.js";
+import ExtensionsManager from "./extensions/extensions-manager.js";
+import { archiveProfile } from "./profile/profile-archiver.js";
+import { checkAutoLang } from "./utils/browser.js";
+import { 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 { zeroProfileBookmarks } from "./utils/zero-profile-bookmarks.js";
+import { zeroProfilePreferences } from "./utils/zero-profile-preferences.js";
+import { tzlookup } from "./utils/timezone.js";
 const { access, unlink, writeFile, readFile, mkdir, copyFile } = _promises;
 
 const SEPARATOR = sep;
 const OS_PLATFORM = process.platform;
-const TIMEZONE_URL = 'https://geo.myip.link';
-const PROXY_NONE = 'none';
+const TIMEZONE_URL = "https://geolocation-db.com/json/";
+// const TIMEZONE_URL = 'https://geo.myip.link';
+const PROXY_NONE = "none";
 
-const debug = debugDefault('gologin');
+const debug = debugDefault("gologin");
 const delay = (time) => new Promise((resolve) => setTimeout(resolve, time));
 
 export class GoLogin {
   constructor(options = {}) {
-    this.browserLang = 'en-US';
+    this.browserLang = "en-US";
     this.access_token = options.token;
     this.profile_id = options.profile_id;
     this.password = options.password;
@@ -57,11 +69,12 @@ export class GoLogin {
     this.is_active = false;
     this.is_stopping = false;
     this.differentOs = false;
-    this.profileOs = 'lin';
+    this.profileOs = "lin";
     this.waitWebsocket = options.waitWebsocket ?? true;
     this.isEmptyFonts = false;
     this.isFirstSession = false;
     this.isCloudHeadless = options.isCloudHeadless ?? true;
+    this.storageGatewayUrl = `${STORAGE_GATEWAY_BASE_URL}/upload`;
 
     this.tmpdir = tmpdir();
     this.autoUpdateBrowser = !!options.autoUpdateBrowser;
@@ -80,25 +93,38 @@ export class GoLogin {
     if (options.tmpdir) {
       this.tmpdir = options.tmpdir;
       if (!existsSync(this.tmpdir)) {
-        debug('making tmpdir', this.tmpdir);
+        debug("making tmpdir", this.tmpdir);
         mkdirSync(this.tmpdir, { recursive: true });
       }
     }
 
     this.profile_zip_path = join(this.tmpdir, `gologin_${this.profile_id}.zip`);
-    this.bookmarksFilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`, 'Default', 'Bookmarks');
-    debug('INIT GOLOGIN', this.profile_id);
+    this.bookmarksFilePath = join(
+      this.tmpdir,
+      `gologin_profile_${this.profile_id}`,
+      "Default",
+      "Bookmarks"
+    );
+    debug("INIT GOLOGIN", this.profile_id);
   }
 
   async checkBrowser() {
-    return this.browserChecker.checkBrowser(this.autoUpdateBrowser, this.checkBrowserUpdate);
+    return this.browserChecker.checkBrowser(
+      this.autoUpdateBrowser,
+      this.checkBrowserUpdate
+    );
   }
 
   async setProfileId(profile_id) {
     this.profile_id = profile_id;
     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');
+    this.bookmarksFilePath = join(
+      this.tmpdir,
+      `gologin_profile_${this.profile_id}`,
+      "Default",
+      "Bookmarks"
+    );
   }
 
   async getToken(username, password) {
@@ -109,21 +135,28 @@ export class GoLogin {
       },
     });
 
-    if (!Reflect.has(data, 'body.access_token')) {
-      throw new Error(`gologin auth failed with status code, ${data.statusCode} DATA  ${JSON.stringify(data)}`);
+    if (!Reflect.has(data, "body.access_token")) {
+      throw new Error(
+        `gologin auth failed with status code, ${
+          data.statusCode
+        } DATA  ${JSON.stringify(data)}`
+      );
     }
   }
 
   async getNewFingerPrint(os) {
-    debug('GETTING FINGERPRINT');
+    debug("GETTING FINGERPRINT");
 
-    const fpResponse = await requests.get(`${API_URL}/browser/fingerprint?os=${os}`, {
-      json: true,
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-    });
+    const fpResponse = await requests.get(
+      `${API_URL}/browser/fingerprint?os=${os}`,
+      {
+        json: true,
+        headers: {
+          Authorization: `Bearer ${this.access_token}`,
+          "User-Agent": "gologin-api",
+        },
+      }
+    );
 
     return fpResponse?.body || {};
   }
@@ -131,14 +164,13 @@ export class GoLogin {
   async profiles() {
     const profilesResponse = await requests.get(`${API_URL}/browser/v2`, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
     });
 
     if (profilesResponse.statusCode !== 200) {
-      throw new Error('Gologin /browser response error');
+      throw new Error("Gologin /browser response error");
     }
 
     return JSON.parse(profilesResponse.body);
@@ -146,23 +178,23 @@ export class GoLogin {
 
   async getProfile(profile_id) {
     const id = profile_id || this.profile_id;
-    debug('getProfile', this.access_token, id);
-    const profileResponse = await requests.get(`${API_URL}/browser/features/${id}/info-for-run`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-    });
+    debug("getProfile", this.access_token, id);
+    const profileResponse = await requests.get(
+      `${API_URL}/browser/features/${id}/info-for-run`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.access_token}`,
+          "User-Agent": "gologin-api",
+        },
+      }
+    );
 
-    debug('profileResponse', profileResponse.statusCode, profileResponse.body);
+    debug("profileResponse", profileResponse.statusCode, profileResponse.body);
 
-    const { body: errorBody = '' } = profileResponse;
-    const backendErrorHeader = 'backend@error::';
+    const { body: errorBody = "" } = profileResponse;
+    const backendErrorHeader = "backend@error::";
     if (errorBody.includes(backendErrorHeader)) {
-      const errorData =
-        errorBody
-          .replace(backendErrorHeader, '')
-          .slice(1, -1);
+      const errorData = errorBody.replace(backendErrorHeader, "").slice(1, -1);
 
       throw new Error(errorData);
     }
@@ -176,25 +208,29 @@ export class GoLogin {
     }
 
     if (profileResponse.statusCode !== 200) {
-      throw new Error(`Gologin /browser/${id} response error ${profileResponse.statusCode} INVALID TOKEN OR PROFILE NOT FOUND`);
+      throw new Error(
+        `Gologin /browser/${id} response error ${profileResponse.statusCode} INVALID TOKEN OR PROFILE NOT FOUND`
+      );
     }
 
     if (profileResponse.statusCode === 401) {
-      throw new Error('invalid token');
+      throw new Error("invalid token");
     }
 
     return JSON.parse(profileResponse.body);
   }
 
   async emptyProfile() {
-    return readFile(_resolve(__dirname, 'gologin_zeroprofile.b64')).then(res => res.toString());
+    return readFile(_resolve(__dirname, "gologin_zeroprofile.b64")).then(
+      (res) => res.toString()
+    );
   }
 
   async getProfileS3() {
     const token = this.access_token;
-    debug('getProfileS3 token=', token, 'profile=', this.profile_id);
+    debug("getProfileS3 token=", token, "profile=", this.profile_id);
     const downloadURL = `${STORAGE_GATEWAY_BASE_URL}/download`;
-    debug('loading profile from public s3 bucket, url=', downloadURL);
+    debug("loading profile from public s3 bucket, url=", downloadURL);
 
     const profileResponse = await fetch(downloadURL, {
       headers: {
@@ -206,28 +242,29 @@ export class GoLogin {
     const profileResponseBody = await profileResponse.arrayBuffer();
 
     if (profileResponse.status !== 200) {
-      debug(`Gologin S3 BUCKET ${downloadURL} response error ${profileResponse.statusCode}  - use empty`);
+      debug(
+        `Gologin S3 BUCKET ${downloadURL} response error ${profileResponse.statusCode}  - use empty`
+      );
 
-      return '';
+      return "";
     }
 
     return Buffer.from(profileResponseBody);
   }
 
   async postFile(fileName, fileBuff) {
-    debug('POSTING FILE', fileBuff.length);
-    debug('Getting signed URL for S3');
-    const apiUrl = `${STORAGE_GATEWAY_BASE_URL}/upload`;
+    debug("POSTING FILE", fileBuff.length);
+    debug("Getting signed URL for S3");
 
     const bodyBufferBiteLength = Buffer.byteLength(fileBuff);
-    console.log('BUFFER SIZE', bodyBufferBiteLength);
+    console.log("BUFFER SIZE", bodyBufferBiteLength);
 
-    await requests.put(apiUrl, {
+    await requests.put(this.storageGatewayUrl, {
       headers: {
         Authorization: `Bearer ${this.access_token}`,
         browserId: this.profile_id,
-        'Content-Type': 'application/zip',
-        'Content-Length': bodyBufferBiteLength,
+        "Content-Type": "application/zip",
+        "Content-Length": bodyBufferBiteLength,
       },
       body: fileBuff,
       maxBodyLength: Infinity,
@@ -238,51 +275,61 @@ export class GoLogin {
       fullResponse: false,
     });
 
-    console.log('Profile has been uploaded to S3 successfully');
+    console.log("Profile has been uploaded to S3 successfully");
   }
 
   async emptyProfileFolder() {
-    debug('get emptyProfileFolder');
-    const currentDir = dirname(new URL(import.meta.url).pathname);
-    const zeroProfilePath = join(currentDir, '..', 'zero_profile.zip');
+    debug("get emptyProfileFolder");
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const zeroProfilePath = join(currentDir, "..", "zero_profile.zip");
     const profile = await readFile(_resolve(zeroProfilePath));
-    debug('emptyProfileFolder LENGTH ::', profile.length);
+    debug("emptyProfileFolder LENGTH ::", profile.length);
 
     return profile;
   }
 
   convertPreferences(preferences) {
-    if (get(preferences, 'navigator.userAgent')) {
-      preferences.userAgent = get(preferences, 'navigator.userAgent');
+    if (get(preferences, "navigator.userAgent")) {
+      preferences.userAgent = get(preferences, "navigator.userAgent");
     }
 
-    if (get(preferences, 'navigator.doNotTrack')) {
-      preferences.doNotTrack = get(preferences, 'navigator.doNotTrack');
+    if (get(preferences, "navigator.doNotTrack")) {
+      preferences.doNotTrack = get(preferences, "navigator.doNotTrack");
     }
 
-    if (get(preferences, 'navigator.hardwareConcurrency')) {
-      preferences.hardwareConcurrency = get(preferences, 'navigator.hardwareConcurrency');
+    if (get(preferences, "navigator.hardwareConcurrency")) {
+      preferences.hardwareConcurrency = get(
+        preferences,
+        "navigator.hardwareConcurrency"
+      );
     }
 
-    if (get(preferences, 'navigator.deviceMemory')) {
-      preferences.deviceMemory = get(preferences, 'navigator.deviceMemory') * 1024;
+    if (get(preferences, "navigator.deviceMemory")) {
+      preferences.deviceMemory =
+        get(preferences, "navigator.deviceMemory") * 1024;
     }
 
-    if (get(preferences, 'navigator.language')) {
-      preferences.langHeader = get(preferences, 'navigator.language');
-      preferences.languages = get(preferences, 'navigator.language').replace(/;|q=[\d\.]+/img, '');
+    if (get(preferences, "navigator.language")) {
+      preferences.langHeader = get(preferences, "navigator.language");
+      preferences.languages = get(preferences, "navigator.language").replace(
+        /;|q=[\d\.]+/gim,
+        ""
+      );
     }
 
-    if (get(preferences, 'navigator.maxTouchPoints')) {
-      preferences.navigator.max_touch_points = get(preferences, 'navigator.maxTouchPoints');
+    if (get(preferences, "navigator.maxTouchPoints")) {
+      preferences.navigator.max_touch_points = get(
+        preferences,
+        "navigator.maxTouchPoints"
+      );
     }
 
-    if (get(preferences, 'isM1')) {
-      preferences.is_m1 = get(preferences, 'isM1');
+    if (get(preferences, "isM1")) {
+      preferences.is_m1 = get(preferences, "isM1");
     }
 
-    if (get(preferences, 'os') == 'android') {
-      const devicePixelRatio = get(preferences, 'devicePixelRatio');
+    if (get(preferences, "os") == "android") {
+      const devicePixelRatio = get(preferences, "devicePixelRatio");
       const deviceScaleFactorCeil = Math.ceil(devicePixelRatio || 3.5);
       let deviceScaleFactor = devicePixelRatio;
       if (deviceScaleFactorCeil === devicePixelRatio) {
@@ -306,8 +353,8 @@ export class GoLogin {
 
     preferences.webRtc = {
       ...preferences.webRtc,
-      fill_based_on_ip: !!get(preferences, 'webRTC.fillBasedOnIp'),
-      local_ip_masking: !!get(preferences, 'webRTC.local_ip_masking'),
+      fill_based_on_ip: !!get(preferences, "webRTC.fillBasedOnIp"),
+      local_ip_masking: !!get(preferences, "webRTC.local_ip_masking"),
     };
 
     return preferences;
@@ -315,68 +362,68 @@ export class GoLogin {
 
   async createBrowserExtension() {
     const that = this;
-    debug('start createBrowserExtension');
+    debug("start createBrowserExtension");
     await rimraf(this.orbitaExtensionPath(), () => null);
     const extPath = this.orbitaExtensionPath();
-    debug('extension folder sanitized');
-    const extension_source = _resolve(__dirname, 'gologin-browser-ext.zip');
-    await decompress(extension_source, extPath,
-      {
-        plugins: [decompressUnzip()],
-        filter: file => !file.path.endsWith('/'),
-      },
-    )
+    debug("extension folder sanitized");
+    const extension_source = _resolve(__dirname, "gologin-browser-ext.zip");
+    await decompress(extension_source, extPath, {
+      plugins: [decompressUnzip()],
+      filter: (file) => !file.path.endsWith("/"),
+    })
       .then(() => {
-        debug('extraction done');
-        debug('create uid.json');
+        debug("extraction done");
+        debug("create uid.json");
 
-        return writeFile(join(extPath, 'uid.json'), JSON.stringify({ uid: that.profile_id }, null, 2))
-          .then(() => extPath);
+        return writeFile(
+          join(extPath, "uid.json"),
+          JSON.stringify({ uid: that.profile_id }, null, 2)
+        ).then(() => extPath);
       })
       .catch(async (e) => {
-        debug('orbita extension error', e);
+        debug("orbita extension error", e);
       });
 
-    debug('createBrowserExtension done');
+    debug("createBrowserExtension done");
   }
 
   extractProfile(path, zipfile) {
     debug(`extactProfile ${zipfile}, ${path}`);
 
-    return decompress(zipfile, path,
-      {
-        plugins: [decompressUnzip()],
-        filter: file => !file.path.endsWith('/'),
-      },
-    );
+    return decompress(zipfile, path, {
+      plugins: [decompressUnzip()],
+      filter: (file) => !file.path.endsWith("/"),
+    });
   }
 
   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);
+    const profileZipExists = await access(this.profile_zip_path)
+      .then(() => true)
+      .catch(() => false);
 
     if (!(local && profileZipExists)) {
       try {
         profile_folder = await this.getProfileS3();
       } catch (e) {
-        debug('Cannot get profile - using empty', e);
+        debug("Cannot get profile - using empty", e);
       }
 
-      debug('FILE READY', this.profile_zip_path);
+      debug("FILE READY", this.profile_zip_path);
 
       await writeFile(this.profile_zip_path, profile_folder);
 
-      debug('PROFILE LENGTH', profile_folder.length);
+      debug("PROFILE LENGTH", profile_folder.length);
     } else {
-      debug('PROFILE LOCAL HAVING', this.profile_zip_path);
+      debug("PROFILE LOCAL HAVING", this.profile_zip_path);
     }
 
-    debug('Cleaning up..', profilePath);
+    debug("Cleaning up..", profilePath);
 
     try {
       await this.extractProfile(profilePath, this.profile_zip_path);
-      debug('extraction done');
+      debug("extraction done");
     } catch (e) {
       console.trace(e);
       profile_folder = await this.emptyProfileFolder();
@@ -384,28 +431,36 @@ export class GoLogin {
       await this.extractProfile(profilePath, this.profile_zip_path);
     }
 
-    const singletonLockPath = join(profilePath, 'SingletonLock');
-    const singletonLockExists = await access(singletonLockPath).then(() => true).catch(() => false);
+    const singletonLockPath = join(profilePath, "SingletonLock");
+    const singletonLockExists = await access(singletonLockPath)
+      .then(() => true)
+      .catch(() => false);
     if (singletonLockExists) {
-      debug('removing SingletonLock');
+      debug("removing SingletonLock");
       await unlink(singletonLockPath);
-      debug('SingletonLock removed');
+      debug("SingletonLock removed");
     }
   }
 
   async createZeroProfile(createCookiesTableQuery) {
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
-    const defaultFilePath = _resolve(profilePath, 'Default');
-    const preferencesFilePath = _resolve(defaultFilePath, 'Preferences');
-    const bookmarksFilePath = _resolve(defaultFilePath, 'Bookmarks');
-    const cookiesFilePath = _resolve(defaultFilePath, 'Network', 'Cookies');
-    const cookiesFileSecondPath = _resolve(defaultFilePath, 'Cookies');
+    const defaultFilePath = _resolve(profilePath, "Default");
+    const preferencesFilePath = _resolve(defaultFilePath, "Preferences");
+    const bookmarksFilePath = _resolve(defaultFilePath, "Bookmarks");
+    const cookiesFilePath = _resolve(defaultFilePath, "Network", "Cookies");
+    const cookiesFileSecondPath = _resolve(defaultFilePath, "Cookies");
 
-    await mkdir(_resolve(defaultFilePath, 'Network'), { recursive: true }).catch(console.log);
+    await mkdir(_resolve(defaultFilePath, "Network"), {
+      recursive: true,
+    }).catch(console.log);
 
     await Promise.all([
-      writeFile(preferencesFilePath, JSON.stringify(zeroProfilePreferences), { mode: 0o666 }),
-      writeFile(bookmarksFilePath, JSON.stringify(zeroProfileBookmarks), { mode: 0o666 }),
+      writeFile(preferencesFilePath, JSON.stringify(zeroProfilePreferences), {
+        mode: 0o666,
+      }),
+      writeFile(bookmarksFilePath, JSON.stringify(zeroProfileBookmarks), {
+        mode: 0o666,
+      }),
       createDBFile({
         cookiesFilePath,
         cookiesFileSecondPath,
@@ -417,25 +472,21 @@ export class GoLogin {
   async createStartup(local = false) {
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
     await rimraf(profilePath, () => null);
-    debug('-', profilePath, 'dropped');
+    debug("-", profilePath, "dropped");
     const profile = await this.getProfile();
     const { navigator = {}, fonts, os: profileOs } = profile;
     this.fontsMasking = fonts?.enableMasking;
     this.profileOs = profileOs;
     this.differentOs =
-      profileOs !== 'android' && (
-        OS_PLATFORM === 'win32' && profileOs !== 'win' ||
-        OS_PLATFORM === 'darwin' && profileOs !== 'mac' ||
-        OS_PLATFORM === 'linux' && profileOs !== 'lin'
-      );
+      profileOs !== "android" &&
+      ((OS_PLATFORM === "win32" && profileOs !== "win") ||
+        (OS_PLATFORM === "darwin" && profileOs !== "mac") ||
+        (OS_PLATFORM === "linux" && profileOs !== "lin"));
 
-    const {
-      resolution = '1920x1080',
-      language = 'en-US,en;q=0.9',
-    } = navigator;
+    const { resolution = "1920x1080", language = "en-US,en;q=0.9" } = navigator;
 
     this.language = language;
-    const [screenWidth, screenHeight] = resolution.split('x');
+    const [screenWidth, screenHeight] = resolution.split("x");
     this.resolution = {
       width: parseInt(screenWidth, 10),
       height: parseInt(screenHeight, 10),
@@ -448,21 +499,27 @@ export class GoLogin {
       await this.downloadProfileAndExtract(profile, local);
     }
 
-    const pref_file_name = join(profilePath, 'Default', 'Preferences');
-    debug('reading', pref_file_name);
+    const pref_file_name = join(profilePath, "Default", "Preferences");
+    debug("reading", pref_file_name);
 
-    const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
+    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 writeFile(pref_file_name, '{}');
+      debug(
+        "Preferences file not exists waiting",
+        pref_file_name,
+        ". Using empty profile"
+      );
+      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 name = get(profile, 'name');
-    const chromeExtensions = get(profile, 'chromeExtensions') || [];
-    const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
+    let proxy = get(profile, "proxy");
+    const name = get(profile, "name");
+    const chromeExtensions = get(profile, "chromeExtensions") || [];
+    const userChromeExtensions = get(profile, "userChromeExtensions") || [];
     const allExtensions = [...chromeExtensions, ...userChromeExtensions];
 
     if (allExtensions.length) {
@@ -470,7 +527,7 @@ export class GoLogin {
       ExtensionsManagerInst.apiUrl = API_URL;
       await ExtensionsManagerInst.init()
         .then(() => ExtensionsManagerInst.updateExtensions())
-        .catch(() => { });
+        .catch(() => {});
       ExtensionsManagerInst.accessToken = this.access_token;
 
       await ExtensionsManagerInst.getExtensionsPolicies();
@@ -479,16 +536,19 @@ export class GoLogin {
       if (ExtensionsManagerInst.useLocalExtStorage) {
         const promises = [
           ExtensionsManagerInst.checkChromeExtensions(allExtensions)
-            .then(res => ({ profileExtensionsCheckRes: res }))
+            .then((res) => ({ profileExtensionsCheckRes: res }))
             .catch((e) => {
-              console.log('checkChromeExtensions error: ', e);
+              console.log("checkChromeExtensions error: ", e);
 
               return { profileExtensionsCheckRes: [] };
             }),
-          ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions, this.profile_id)
-            .then(res => ({ profileUserExtensionsCheckRes: res }))
+          ExtensionsManagerInst.checkLocalUserChromeExtensions(
+            userChromeExtensions,
+            this.profile_id
+          )
+            .then((res) => ({ profileUserExtensionsCheckRes: res }))
             .catch((error) => {
-              console.log('checkUserChromeExtensions error: ', error);
+              console.log("checkUserChromeExtensions error: ", error);
 
               return null;
             }),
@@ -496,22 +556,43 @@ export class GoLogin {
 
         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 || []);
+        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);
+        extSettings = await setExtPathsAndRemoveDeleted(
+          preferences,
+          profileExtensionsCheckRes,
+          this.profile_id
+        );
       } else {
-        const originalExtensionsFolder = join(profilePath, 'Default', 'Extensions');
-        extSettings = await setOriginalExtPaths(preferences, originalExtensionsFolder);
+        const originalExtensionsFolder = join(
+          profilePath,
+          "Default",
+          "Extensions"
+        );
+        extSettings = await setOriginalExtPaths(
+          preferences,
+          originalExtensionsFolder
+        );
       }
 
       this.extensionPathsToInstall =
-        ExtensionsManagerInst.getExtensionsToInstall(extSettings, profileExtensionsCheckRes);
+        ExtensionsManagerInst.getExtensionsToInstall(
+          extSettings,
+          profileExtensionsCheckRes
+        );
 
       if (extSettings) {
         const currentExtSettings = preferences.extensions || {};
@@ -520,26 +601,26 @@ export class GoLogin {
       }
     }
 
-    if (proxy.mode === 'gologin' || proxy.mode === 'tor') {
-      const autoProxyServer = get(profile, 'autoProxyServer');
-      const splittedAutoProxyServer = autoProxyServer.split('://');
-      const splittedProxyAddress = splittedAutoProxyServer[1].split(':');
+    if (proxy.mode === "gologin" || proxy.mode === "tor") {
+      const autoProxyServer = get(profile, "autoProxyServer");
+      const splittedAutoProxyServer = autoProxyServer.split("://");
+      const splittedProxyAddress = splittedAutoProxyServer[1].split(":");
       const port = splittedProxyAddress[1];
 
       proxy = {
-        'mode': splittedAutoProxyServer[0],
-        'host': splittedProxyAddress[0],
+        mode: splittedAutoProxyServer[0],
+        host: splittedProxyAddress[0],
         port,
-        'username': get(profile, 'autoProxyUsername'),
-        'password': get(profile, 'autoProxyPassword'),
+        username: get(profile, "autoProxyUsername"),
+        password: get(profile, "autoProxyPassword"),
       };
 
-      profile.proxy.username = get(profile, 'autoProxyUsername');
-      profile.proxy.password = get(profile, 'autoProxyPassword');
+      profile.proxy.username = get(profile, "autoProxyUsername");
+      profile.proxy.password = get(profile, "autoProxyPassword");
     }
 
-    if (proxy.mode === 'geolocation') {
-      proxy.mode = 'http';
+    if (proxy.mode === "geolocation") {
+      proxy.mode = "http";
     }
 
     if (proxy.mode === PROXY_NONE) {
@@ -549,7 +630,7 @@ export class GoLogin {
     this.proxy = proxy;
 
     await this.getTimeZone(proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
+      console.error("Proxy Error. Check it and try again.");
       throw new Error(`Proxy Error. ${e.message}`);
     });
 
@@ -563,23 +644,31 @@ export class GoLogin {
       accuracy,
     };
 
-    profile.geoLocation = this.getGeolocationParams(profileGeolocation, tzGeoLocation);
+    profile.geoLocation = this.getGeolocationParams(
+      profileGeolocation,
+      tzGeoLocation
+    );
     profile.name = name;
-    profile.name_base64 = Buffer.from(name).toString('base64');
+    profile.name_base64 = Buffer.from(name).toString("base64");
     profile.profile_id = this.profile_id;
 
     profile.webRtc = {
-      mode: get(profile, 'webRTC.mode') === 'alerted' ? 'public' : get(profile, 'webRTC.mode'),
-      publicIP: get(profile, 'webRTC.fillBasedOnIp') ? this._tz.ip : get(profile, 'webRTC.publicIp'),
-      localIps: get(profile, 'webRTC.localIps', []),
+      mode:
+        get(profile, "webRTC.mode") === "alerted"
+          ? "public"
+          : get(profile, "webRTC.mode"),
+      publicIP: get(profile, "webRTC.fillBasedOnIp")
+        ? this._tz.ip
+        : get(profile, "webRTC.publicIp"),
+      localIps: get(profile, "webRTC.localIps", []),
     };
 
-    debug('profile.webRtc=', profile.webRtc);
-    debug('profile.timezone=', profile.timezone);
-    debug('profile.mediaDevices=', profile.mediaDevices);
+    debug("profile.webRtc=", profile.webRtc);
+    debug("profile.timezone=", profile.timezone);
+    debug("profile.mediaDevices=", profile.mediaDevices);
 
     const audioContext = profile.audioContext || {};
-    const { mode: audioCtxMode = 'off', noise: audioCtxNoise } = audioContext;
+    const { mode: audioCtxMode = "off", noise: audioCtxNoise } = audioContext;
     if (profile.timezone.fillBasedOnIp === false) {
       profile.timezone = { id: profile.timezone.timezone };
     } else {
@@ -591,14 +680,14 @@ export class GoLogin {
     profile.canvasMode = profile.canvas.mode;
     profile.canvasNoise = profile.canvas.noise;
     profile.audioContext = {
-      enable: audioCtxMode !== 'off',
+      enable: audioCtxMode !== "off",
       noiseValue: audioCtxNoise,
     };
     profile.webgl = {
       metadata: {
-        vendor: get(profile, 'webGLMetadata.vendor'),
-        renderer: get(profile, 'webGLMetadata.renderer'),
-        mode: get(profile, 'webGLMetadata.mode') === 'mask',
+        vendor: get(profile, "webGLMetadata.vendor"),
+        renderer: get(profile, "webGLMetadata.renderer"),
+        mode: get(profile, "webGLMetadata.mode") === "mask",
       },
     };
 
@@ -608,11 +697,17 @@ export class GoLogin {
 
     const gologin = this.convertPreferences(profile);
 
-    debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
+    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);
+    debug("writeCookiesFromServer", this.writeCookiesFromServer);
+    this.cookiesFilePath = await getCookiesFilePath(
+      this.profile_id,
+      this.tmpdir
+    );
 
     if (this.writeCookiesFromServer) {
       await this.writeCookiesToFile(profile.cookies?.cookies);
@@ -631,7 +726,7 @@ export class GoLogin {
       }
     }
 
-    const languages = this.language.replace(/;|q=[\d\.]+/img, '');
+    const languages = this.language.replace(/;|q=[\d\.]+/gim, "");
 
     if (preferences.gologin == null) {
       preferences.gologin = {};
@@ -640,24 +735,41 @@ export class GoLogin {
     preferences.gologin.langHeader = gologin.navigator.language;
     preferences.gologin.language = languages;
 
-    const [splittedLangs] = gologin.navigator.language.split(';');
-    const [browserLang] = splittedLangs.split(',');
+    const [splittedLangs] = gologin.navigator.language.split(";");
+    const [browserLang] = splittedLangs.split(",");
     gologin.browserLang = browserLang;
 
-    const isMAC = OS_PLATFORM === 'darwin';
+    const isMAC = OS_PLATFORM === "darwin";
     const checkAutoLangResult = checkAutoLang(gologin, this._tz);
-    this.browserLang = isMAC ? 'en-US' : checkAutoLangResult;
-
-    await writeFile(join(profilePath, 'Default', 'Preferences'), JSON.stringify(Object.assign(preferences, {
-      gologin,
-    })));
+    this.browserLang = isMAC ? "en-US" : checkAutoLangResult;
+
+    await writeFile(
+      join(profilePath, "Default", "Preferences"),
+      JSON.stringify(
+        Object.assign(preferences, {
+          gologin,
+        })
+      )
+    );
 
-    const bookmarksParsedData = await getCurrentProfileBookmarks(this.bookmarksFilePath);
+    const bookmarksParsedData = await getCurrentProfileBookmarks(
+      this.bookmarksFilePath
+    );
     const bookmarksFromDb = profile.bookmarks?.bookmark_bar;
-    bookmarksParsedData.roots = bookmarksFromDb ? profile.bookmarks : bookmarksParsedData.roots;
-    await writeFile(this.bookmarksFilePath, JSON.stringify(bookmarksParsedData));
+    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')));
+    debug(
+      "Profile ready. Path: ",
+      profilePath,
+      "PROXY",
+      JSON.stringify(get(preferences, "gologin.proxy"))
+    );
 
     return profilePath;
   }
@@ -665,21 +777,21 @@ export class GoLogin {
   async commitProfile() {
     const dataBuff = await this.getProfileDataToUpdate();
 
-    debug('begin updating', dataBuff.length);
+    debug("begin updating", dataBuff.length);
     if (!dataBuff.length) {
-      debug('WARN: profile zip data empty - SKIPPING PROFILE COMMIT');
+      debug("WARN: profile zip data empty - SKIPPING PROFILE COMMIT");
 
       return;
     }
 
     try {
-      debug('Patching profile');
-      await this.postFile('profile', dataBuff);
+      debug("Patching profile");
+      await this.postFile("profile", dataBuff);
     } catch (e) {
-      debug('CANNOT COMMIT PROFILE', e);
+      debug("CANNOT COMMIT PROFILE", e);
     }
 
-    debug('COMMIT COMPLETED');
+    debug("COMMIT COMPLETED");
   }
 
   profilePath() {
@@ -698,10 +810,10 @@ export class GoLogin {
   }
 
   async checkPortAvailable(port) {
-    debug('CHECKING PORT AVAILABLE', port);
+    debug("CHECKING PORT AVAILABLE", port);
 
     try {
-      const portAvailable = await isPortReachable(port, { host: 'localhost' });
+      const portAvailable = await isPortReachable(port, { host: "localhost" });
       if (portAvailable) {
         debug(`PORT ${port} IS OPEN`);
 
@@ -728,10 +840,10 @@ export class GoLogin {
   }
 
   async getTimeZone(proxy) {
-    debug('getting timeZone proxy=', proxy);
+    debug("getting timeZone proxy=", proxy);
 
     if (this.timezone) {
-      debug('getTimeZone from options', this.timezone);
+      debug("getTimeZone from options", this.timezone);
       this._tz = this.timezone;
 
       return this._tz.timezone;
@@ -739,50 +851,81 @@ export class GoLogin {
 
     let data = null;
     if (proxy && proxy.mode !== PROXY_NONE) {
-      if (proxy.mode.includes('socks')) {
+      if (proxy.mode.includes("socks")) {
         for (let i = 0; i < 5; i++) {
           try {
-            debug('getting timeZone socks try', i + 1);
+            debug("getting timeZone socks try", i + 1);
 
             return this.getTimezoneWithSocks(proxy);
           } catch (e) {
             console.log(e.message);
           }
         }
-        throw new Error('Socks proxy connection timed out');
+        throw new Error("Socks proxy connection timed out");
       }
 
       const proxyUrl = `${proxy.mode}://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`;
       debug(`getTimeZone start ${TIMEZONE_URL}`, proxyUrl);
-      data = await requests.get(TIMEZONE_URL, { proxy: proxyUrl, timeout: 20 * 1000, maxAttempts: 5 });
+      const response = await requests.get(TIMEZONE_URL, {
+        proxy: proxyUrl,
+        timeout: 20 * 1000,
+        maxAttempts: 5,
+      });
+      const result = JSON.parse(response.body);
+      data = {
+        body: {
+          country: result.country_code,
+          stateProv: result.city,
+          city: result.city,
+          timezone: tzlookup(result.latitude, result.longitude),
+          ll: [result.latitude, result.longitude],
+          languages: "en",
+          accuracy: 100,
+        },
+      };
     } else {
-      data = await requests.get(TIMEZONE_URL, { timeout: 20 * 1000, maxAttempts: 5 });
+      const response = await requests.get(TIMEZONE_URL, {
+        timeout: 20 * 1000,
+        maxAttempts: 5,
+      });
+      const result = JSON.parse(response.body);
+      data = {
+        body: {
+          country: result.country_code,
+          stateProv: result.city,
+          city: result.city,
+          timezone: tzlookup(result.latitude, result.longitude),
+          ll: [result.latitude, result.longitude],
+          languages: "en",
+          accuracy: 100,
+        },
+      };
     }
 
-    debug('getTimeZone finish', data.body);
-    this._tz = JSON.parse(data.body);
+    debug("getTimeZone finish", data.body);
+    this._tz = data.body;
 
     return this._tz.timezone;
   }
 
   async getTimezoneWithSocks(params) {
-    const { host, port, username = '', password = '' } = params;
+    const { host, port, username = "", password = "" } = params;
     let body;
 
-    let proxy = 'socks://';
+    let proxy = "socks://";
     if (username) {
-      const resultPassword = password ? ':' + password + '@' : '@';
+      const resultPassword = password ? ":" + password + "@" : "@";
       proxy += username + resultPassword;
     }
 
-    proxy += host + ':' + port;
+    proxy += host + ":" + port;
     const agent = new SocksProxyAgent(proxy);
     const checkData = await new Promise((resolve, reject) => {
       _get(TIMEZONE_URL, { agent, timeout: 10000 }, (res) => {
-        let resultResponse = '';
-        res.on('data', (data) => resultResponse += data);
+        let resultResponse = "";
+        res.on("data", (data) => (resultResponse += data));
 
-        res.on('end', () => {
+        res.on("end", () => {
           let parsedData;
           try {
             parsedData = JSON.parse(resultResponse);
@@ -795,15 +938,15 @@ export class GoLogin {
             body: parsedData,
           });
         });
-      }).on('error', (err) => reject(err));
+      }).on("error", (err) => reject(err));
     });
 
     body = checkData.body || {};
-    if (!body.ip && checkData.statusCode.toString().startsWith('4')) {
+    if (!body.ip && checkData.statusCode.toString().startsWith("4")) {
       throw checkData;
     }
 
-    debug('getTimeZone finish', body.body);
+    debug("getTimeZone finish", body.body);
     this._tz = body;
 
     return this._tz.timezone;
@@ -821,13 +964,19 @@ export class GoLogin {
     });
 
     const tz = await this.getTimeZone(this.proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
+      console.error("Proxy Error. Check it and try again.");
       throw e;
     });
 
     env.TZ = tz;
 
-    let params = [`--proxy-server=${proxy}`, `--user-data-dir=${profile_path}`, '--password-store=basic', `--tz=${tz}`, '--lang=en'];
+    let params = [
+      `--proxy-server=${proxy}`,
+      `--user-data-dir=${profile_path}`,
+      "--password-store=basic",
+      `--tz=${tz}`,
+      "--lang=en",
+    ];
     if (Array.isArray(this.extra_params) && this.extra_params.length) {
       params = params.concat(this.extra_params);
     }
@@ -848,7 +997,7 @@ export class GoLogin {
     const profile_path = this.profilePath();
 
     let { proxy } = this;
-    let proxy_host = '';
+    let proxy_host = "";
     if (proxy) {
       proxy_host = this.proxy.host;
       proxy = `${proxy.mode}://${proxy.host}:${proxy.port}`;
@@ -856,7 +1005,8 @@ export class GoLogin {
 
     this.port = remote_debugging_port;
 
-    const ORBITA_BROWSER = this.executablePath || this.browserChecker.getOrbitaPath;
+    const ORBITA_BROWSER =
+      this.executablePath || this.browserChecker.getOrbitaPath;
     debug(`ORBITA_BROWSER=${ORBITA_BROWSER}`);
     const env = {};
     Object.keys(process.env).forEach((key) => {
@@ -864,25 +1014,40 @@ export class GoLogin {
     });
 
     const tz = await this.getTimeZone(this.proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
+      console.error("Proxy Error. Check it and try again.");
       throw e;
     });
 
     env.TZ = tz;
 
     if (this.vnc_port) {
-      const script_path = _resolve(__dirname, './run.sh');
-      debug('RUNNING', script_path, ORBITA_BROWSER, remote_debugging_port, proxy, profile_path, this.vnc_port);
+      const script_path = _resolve(__dirname, "./run.sh");
+      debug(
+        "RUNNING",
+        script_path,
+        ORBITA_BROWSER,
+        remote_debugging_port,
+        proxy,
+        profile_path,
+        this.vnc_port
+      );
       execFile(
         script_path,
-        [ORBITA_BROWSER, remote_debugging_port, proxy, profile_path, this.vnc_port, tz],
-        { env },
+        [
+          ORBITA_BROWSER,
+          remote_debugging_port,
+          proxy,
+          profile_path,
+          this.vnc_port,
+          tz,
+        ],
+        { env }
       );
     } else {
       let params = [
         `--remote-debugging-port=${remote_debugging_port}`,
         `--user-data-dir=${profile_path}`,
-        '--password-store=basic',
+        "--password-store=basic",
         `--tz=${tz}`,
         `--lang=${this.browserLang}`,
       ];
@@ -890,28 +1055,33 @@ export class GoLogin {
       if (this.extensionPathsToInstall.length) {
         if (Array.isArray(this.extra_params) && this.extra_params.length) {
           this.extra_params.forEach((param, index) => {
-            if (!param.includes('--load-extension=')) {
+            if (!param.includes("--load-extension=")) {
               return;
             }
 
-            const [_, extPathsString] = param.split('=');
-            const extPathsArray = extPathsString.split(',');
-            this.extensionPathsToInstall = [...this.extensionPathsToInstall, ...extPathsArray];
+            const [_, extPathsString] = param.split("=");
+            const extPathsArray = extPathsString.split(",");
+            this.extensionPathsToInstall = [
+              ...this.extensionPathsToInstall,
+              ...extPathsArray,
+            ];
             this.extra_params.splice(index, 1);
           });
         }
 
-        params.push(`--load-extension=${this.extensionPathsToInstall.join(',')}`);
+        params.push(
+          `--load-extension=${this.extensionPathsToInstall.join(",")}`
+        );
       }
 
       if (this.fontsMasking) {
-        let arg = '--font-masking-mode=2';
+        let arg = "--font-masking-mode=2";
         if (this.differentOs) {
-          arg = '--font-masking-mode=3';
+          arg = "--font-masking-mode=3";
         }
 
-        if (this.profileOs === 'android' || this.isEmptyFonts) {
-          arg = '--font-masking-mode=1';
+        if (this.profileOs === "android" || this.isEmptyFonts) {
+          arg = "--font-masking-mode=1";
         }
 
         params.push(arg);
@@ -928,7 +1098,7 @@ export class GoLogin {
       }
 
       if (!this.isFirstSession && this.restoreLastSession) {
-        params.push('--restore-last-session');
+        params.push("--restore-last-session");
       }
 
       params.push(...new Set(customArgs));
@@ -937,21 +1107,24 @@ export class GoLogin {
       const child = execFile(ORBITA_BROWSER, params, { env });
       this.processSpawned = child;
       // const child = spawn(ORBITA_BROWSER, params, { env, shell: true });
-      child.stdout.on('data', (data) => debug(data.toString()));
-      debug('SPAWN CMD', ORBITA_BROWSER, params.join(' '));
+      child.stdout.on("data", (data) => debug(data.toString()));
+      debug("SPAWN CMD", ORBITA_BROWSER, params.join(" "));
     }
 
     if (this.waitWebsocket) {
-      debug('GETTING WS URL FROM BROWSER');
-      const data = await requests.get(`http://127.0.0.1:${remote_debugging_port}/json/version`, { json: true });
+      debug("GETTING WS URL FROM BROWSER");
+      const data = await requests.get(
+        `http://127.0.0.1:${remote_debugging_port}/json/version`,
+        { json: true }
+      );
 
-      debug('WS IS', get(data, 'body.webSocketDebuggerUrl', ''));
+      debug("WS IS", get(data, "body.webSocketDebuggerUrl", ""));
       this.is_active = true;
 
-      return get(data, 'body.webSocketDebuggerUrl', '');
+      return get(data, "body.webSocketDebuggerUrl", "");
     }
 
-    return '';
+    return "";
   }
 
   async createStartupAndSpawnBrowser() {
@@ -961,8 +1134,14 @@ 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 rimraf(
+      join(this.tmpdir, `gologin_profile_${this.profile_id}`),
+      () => null
+    );
+    await rimraf(
+      join(this.tmpdir, `gologin_${this.profile_id}_upload.zip`),
+      () => null
+    );
   }
 
   async stopAndCommit(options, local = false) {
@@ -970,19 +1149,20 @@ export class GoLogin {
       return true;
     }
 
-    const is_posting = options.posting ||
+    const is_posting =
+      options.posting ||
       options.postings || // backward compability
       false;
 
     if (this.uploadCookiesToServer) {
-      await this.uploadProfileCookiesToServer();
+      const updateResult = await this.uploadProfileDataToServer();
+      this.storageGatewayUrl = updateResult.storageGateway.url;
     }
 
     this.is_stopping = true;
     await this.sanitizeProfile();
 
     if (is_posting) {
-      await this.saveBookmarksToDb();
       await this.commitProfile();
     }
 
@@ -992,7 +1172,10 @@ export class GoLogin {
     await this.clearProfileFiles();
 
     if (!local) {
-      await rimraf(join(this.tmpdir, `gologin_${this.profile_id}.zip`), () => null);
+      await rimraf(
+        join(this.tmpdir, `gologin_${this.profile_id}.zip`),
+        () => null
+      );
     }
 
     debug(`PROFILE ${this.profile_id} STOPPED AND CLEAR`);
@@ -1000,22 +1183,50 @@ export class GoLogin {
     return false;
   }
 
+  async uploadProfileDataToServer() {
+    const cookies = await loadCookiesFromFile(this.cookiesFilePath);
+    const bookmarks = await getCurrentProfileBookmarks(this.bookmarksFilePath);
+
+    const body = {
+      cookies,
+      bookmarks,
+      isCookiesEncrypted: true,
+      isStorageGateway: true,
+    };
+
+    const updateResult = await requests
+      .post(
+        `${API_URL}/browser/features/profile/${this.profile_id}/update_after_close`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.access_token}`,
+            "User-Agent": "gologin-api",
+          },
+          json: body,
+          maxAttempts: 3,
+          retryDelay: 2000,
+          timeout: 20 * 1000,
+        }
+      )
+      .catch((e) => {
+        console.log(e);
+
+        return e;
+      });
+
+    return updateResult.body;
+  }
+
   async stopBrowser() {
     if (!this.port) {
-      throw new Error('Empty GoLogin port');
+      throw new Error("Empty GoLogin port");
     }
 
-    const ls = await spawn('fuser',
-      [
-        '-k TERM',
-        `-n tcp ${this.port}`,
-      ],
-      {
-        shell: true,
-      },
-    );
+    const ls = await spawn("fuser", ["-k TERM", `-n tcp ${this.port}`], {
+      shell: true,
+    });
 
-    debug('browser killed');
+    debug("browser killed");
   }
 
   killBrowser() {
@@ -1025,7 +1236,7 @@ export class GoLogin {
 
     try {
       this.processSpawned.kill();
-      debug('browser killed');
+      debug("browser killed");
     } catch (error) {
       console.error(error);
     }
@@ -1064,33 +1275,37 @@ export class GoLogin {
 
     const that = this;
 
-    await Promise.all(remove_dirs.map(d => {
-      const path_to_remove = `${that.profilePath()}${d}`;
+    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 new Promise((resolve) => {
+          debug("DROPPING", path_to_remove);
+          rimraf(path_to_remove, { maxBusyTries: 100 }, (e) => {
+            // debug('DROPPING RESULT', e);
+            resolve();
+          });
         });
-      });
-    }));
+      })
+    );
   }
 
   async getProfileDataToUpdate() {
     const zipPath = join(this.tmpdir, `gologin_${this.profile_id}_upload.zip`);
-    const zipExists = await access(zipPath).then(() => true).catch(() => false);
+    const zipExists = await access(zipPath)
+      .then(() => true)
+      .catch(() => false);
     if (zipExists) {
       await unlink(zipPath);
     }
 
     await this.sanitizeProfile();
-    debug('profile sanitized');
+    debug("profile sanitized");
 
     const profilePath = this.profilePath();
     const fileBuff = await archiveProfile(profilePath);
 
-    debug('PROFILE ZIP CREATED', profilePath, zipPath);
+    debug("PROFILE ZIP CREATED", profilePath, zipPath);
 
     return fileBuff;
   }
@@ -1098,25 +1313,23 @@ export class GoLogin {
   async profileExists() {
     const profileResponse = await requests.post(`${API_URL}/browser`, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: {
-
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
+      json: {},
     });
 
     if (profileResponse.statusCode !== 200) {
       return false;
     }
 
-    debug('profile is', profileResponse.body);
+    debug("profile is", profileResponse.body);
 
     return true;
   }
 
   async getRandomFingerprint(options) {
-    let os = 'lin';
+    let os = "lin";
 
     if (options.os) {
       os = options.os;
@@ -1124,13 +1337,13 @@ export class GoLogin {
 
     let url = `${API_URL}/browser/fingerprint?os=${os}`;
     if (options.isM1) {
-      url += '&isM1=true';
+      url += "&isM1=true";
     }
 
     const fingerprint = await requests.get(url, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
     });
 
@@ -1138,17 +1351,17 @@ export class GoLogin {
   }
 
   async create(options) {
-    debug('createProfile', options);
+    debug("createProfile", options);
 
     const fingerprint = await this.getRandomFingerprint(options);
-    debug('fingerprint=', fingerprint);
+    debug("fingerprint=", fingerprint);
 
     if (fingerprint.statusCode === 500) {
-      throw new Error('no valid random fingerprint check os param');
+      throw new Error("no valid random fingerprint check os param");
     }
 
     if (fingerprint.statusCode === 401) {
-      throw new Error('invalid token');
+      throw new Error("invalid token");
     }
 
     const { navigator, fonts, webGLMetadata, webRTC } = fingerprint;
@@ -1158,28 +1371,28 @@ export class GoLogin {
     }
 
     navigator.deviceMemory = deviceMemory * 1024;
-    webGLMetadata.mode = webGLMetadata.mode === 'noise' ? 'mask' : 'off';
+    webGLMetadata.mode = webGLMetadata.mode === "noise" ? "mask" : "off";
 
     const json = {
       ...fingerprint,
       navigator,
       webGLMetadata,
-      browserType: 'chrome',
-      name: 'default_name',
-      notes: 'auto generated',
+      browserType: "chrome",
+      name: "default_name",
+      notes: "auto generated",
       fonts: {
         families: fonts,
       },
       webRTC: {
         ...webRTC,
-        mode: 'alerted',
+        mode: "alerted",
       },
     };
 
     const user_agent = options.navigator?.userAgent;
     const orig_user_agent = json.navigator.userAgent;
     Object.keys(options).forEach((key) => {
-      if (typeof json[key] === 'object') {
+      if (typeof json[key] === "object") {
         json[key] = { ...json[key], ...options[key] };
 
         return;
@@ -1188,24 +1401,30 @@ export class GoLogin {
       json[key] = options[key];
     });
 
-    if (user_agent === 'random') {
+    if (user_agent === "random") {
       json.navigator.userAgent = orig_user_agent;
     }
 
     const response = await requests.post(`${API_URL}/browser`, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
       json,
     });
 
     if (response.statusCode === 400) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode} DATA  ${JSON.stringify(response.body.message)}`);
+      throw new Error(
+        `gologin failed account creation with status code, ${
+          response.statusCode
+        } DATA  ${JSON.stringify(response.body.message)}`
+      );
     }
 
     if (response.statusCode === 500) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode}`);
+      throw new Error(
+        `gologin failed account creation with status code, ${response.statusCode}`
+      );
     }
 
     debug(JSON.stringify(response.body));
@@ -1214,21 +1433,27 @@ export class GoLogin {
   }
 
   async createCustom(options) {
-    debug('createCustomProfile', options);
+    debug("createCustomProfile", options);
     const response = await requests.post(`${API_URL}/browser/custom`, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
       json: options,
     });
 
     if (response.statusCode === 400) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode} DATA  ${JSON.stringify(response.body.message)}`);
+      throw new Error(
+        `gologin failed account creation with status code, ${
+          response.statusCode
+        } DATA  ${JSON.stringify(response.body.message)}`
+      );
     }
 
     if (response.statusCode === 500) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode}`);
+      throw new Error(
+        `gologin failed account creation with status code, ${response.statusCode}`
+      );
     }
 
     debug(JSON.stringify(response));
@@ -1236,31 +1461,32 @@ export class GoLogin {
     return response.body.id;
   }
 
-  async quickCreateProfile(name = '') {
+  async quickCreateProfile(name = "") {
     const osInfo = await getOsAdvanced();
     const { os, osSpec } = osInfo;
-    const resultName = name || 'api-generated';
-
-    return requests.post(`${API_URL}/browser/quick`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: {
-        os,
-        osSpec,
-        name: resultName,
-      },
-    })
-      .then(res => res.body);
+    const resultName = name || "api-generated";
+
+    return requests
+      .post(`${API_URL}/browser/quick`, {
+        headers: {
+          Authorization: `Bearer ${this.access_token}`,
+          "User-Agent": "gologin-api",
+        },
+        json: {
+          os,
+          osSpec,
+          name: resultName,
+        },
+      })
+      .then((res) => res.body);
   }
 
   async delete(pid) {
     const profile_id = pid || this.profile_id;
     await requests.delete(`${API_URL}/browser/${profile_id}`, {
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
     });
   }
@@ -1275,20 +1501,22 @@ export class GoLogin {
       });
     }
 
-    Object.keys(options).filter(el => el !== 'navigator').forEach((el) => {
-      profile[el] = options[el];
-    });
+    Object.keys(options)
+      .filter((el) => el !== "navigator")
+      .forEach((el) => {
+        profile[el] = options[el];
+      });
 
-    debug('update profile', profile);
+    debug("update profile", profile);
     const response = await requests.put(`${API_URL}/browser/${options.id}`, {
       json: profile,
       headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
+        Authorization: `Bearer ${this.access_token}`,
+        "User-Agent": "gologin-api",
       },
     });
 
-    debug('response', JSON.stringify(response.body));
+    debug("response", JSON.stringify(response.body));
 
     return response.body;
   }
@@ -1320,9 +1548,13 @@ export class GoLogin {
   }
 
   async postCookies(profileId, cookies) {
-    const formattedCookies = cookies.map(cookie => {
-      if (!['no_restriction', 'lax', 'strict', 'unspecified'].includes(cookie.sameSite)) {
-        cookie.sameSite = 'unspecified';
+    const formattedCookies = cookies.map((cookie) => {
+      if (
+        !["no_restriction", "lax", "strict", "unspecified"].includes(
+          cookie.sameSite
+        )
+      ) {
+        cookie.sameSite = "unspecified";
       }
 
       return cookie;
@@ -1339,7 +1571,11 @@ export class GoLogin {
       return response.body;
     }
 
-    return { status: 'failure', status_code: response.statusCode, body: response.body };
+    return {
+      status: "failure",
+      status_code: response.statusCode,
+      body: response.body,
+    };
   }
 
   async getCookies(profileId) {
@@ -1353,12 +1589,12 @@ export class GoLogin {
   }
 
   getCookiePath(defaultFilePath) {
-    let primary = join(defaultFilePath, 'Cookies');
-    let secondary = join(defaultFilePath, 'Network', 'Cookies');
+    let primary = join(defaultFilePath, "Cookies");
+    let secondary = join(defaultFilePath, "Network", "Cookies");
 
     if (!existsSync(primary)) {
-      primary = join(defaultFilePath, 'Network', 'Cookies');
-      secondary = join(defaultFilePath, 'Cookies');
+      primary = join(defaultFilePath, "Network", "Cookies");
+      secondary = join(defaultFilePath, "Cookies");
     }
 
     return { primary, secondary };
@@ -1373,15 +1609,21 @@ export class GoLogin {
       return;
     }
 
-    const resultCookies = cookies.map((el) => ({ ...el, value: Buffer.from(el.value) }));
+    const resultCookies = cookies.map((el) => ({
+      ...el,
+      value: Buffer.from(el.value),
+    }));
     let db;
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
 
-    const defaultFilePath = _resolve(profilePath, 'Default');
+    const defaultFilePath = _resolve(profilePath, "Default");
     const cookiesPaths = this.getCookiePath(defaultFilePath);
     try {
       db = await getDB(cookiesPaths.primary, false);
-      const cookiesToInsert = await getUniqueCookies(resultCookies, cookiesPaths.primary);
+      const cookiesToInsert = await getUniqueCookies(
+        resultCookies,
+        cookiesPaths.primary
+      );
       if (cookiesToInsert.length) {
         const chunckInsertValues = getChunckedInsertValues(cookiesToInsert);
         for (const [query, queryParams] of chunckInsertValues) {
@@ -1393,8 +1635,10 @@ export class GoLogin {
     } catch (error) {
       console.log(error.message);
     } finally {
-      db && await db.close();
-      await copyFile(cookiesPaths.primary, cookiesPaths.secondary).catch(console.log);
+      db && (await db.close());
+      await copyFile(cookiesPaths.primary, cookiesPaths.secondary).catch(
+        console.log
+      );
     }
   }
 
@@ -1408,9 +1652,15 @@ export class GoLogin {
   }
 
   async saveBookmarksToDb() {
-    const bookmarksData = await getCurrentProfileBookmarks(this.bookmarksFilePath);
+    const bookmarksData = await getCurrentProfileBookmarks(
+      this.bookmarksFilePath
+    );
     const bookmarks = bookmarksData.roots || {};
-    await updateProfileBookmarks([this.profile_id], this.access_token, bookmarks);
+    await updateProfileBookmarks(
+      [this.profile_id],
+      this.access_token,
+      bookmarks
+    );
   }
 
   async start() {
@@ -1418,11 +1668,16 @@ export class GoLogin {
       await this.checkBrowser();
     }
 
-    const ORBITA_BROWSER = this.executablePath || this.browserChecker.getOrbitaPath;
+    const ORBITA_BROWSER =
+      this.executablePath || this.browserChecker.getOrbitaPath;
 
-    const orbitaBrowserExists = await access(ORBITA_BROWSER).then(() => true).catch(() => false);
+    const orbitaBrowserExists = await access(ORBITA_BROWSER)
+      .then(() => true)
+      .catch(() => false);
     if (!orbitaBrowserExists) {
-      throw new Error(`Orbita browser is not exists on path ${ORBITA_BROWSER}, check executablePath param`);
+      throw new Error(
+        `Orbita browser is not exists on path ${ORBITA_BROWSER}, check executablePath param`
+      );
     }
 
     await this.createStartup();
@@ -1430,7 +1685,7 @@ export class GoLogin {
     const wsUrl = await this.spawnBrowser();
     this.setActive(true);
 
-    return { status: 'success', wsUrl };
+    return { status: "success", wsUrl };
   }
 
   async startLocal() {
@@ -1439,11 +1694,11 @@ export class GoLogin {
     const wsUrl = await this.spawnBrowser();
     this.setActive(true);
 
-    return { status: 'success', wsUrl };
+    return { status: "success", wsUrl };
   }
 
   async stop() {
-    await new Promise(resolve => setTimeout(resolve, 500));
+    await new Promise((resolve) => setTimeout(resolve, 500));
 
     await this.stopAndCommit({ posting: true }, false);
   }
@@ -1456,10 +1711,10 @@ export class GoLogin {
   async waitDebuggingUrl(delay_ms, try_count = 0, remoteOrbitaUrl) {
     await delay(delay_ms);
     const url = `${remoteOrbitaUrl}/json/version`;
-    console.log('try_count=', try_count, 'url=', url);
+    console.log("try_count=", try_count, "url=", url);
     const response = await requests.get(url);
-    let wsUrl = '';
-    console.log('response', response.body);
+    let wsUrl = "";
+    console.log("response", response.body);
 
     if (!response.body) {
       return wsUrl;
@@ -1473,23 +1728,36 @@ export class GoLogin {
         return this.waitDebuggingUrl(delay_ms, try_count + 1, remoteOrbitaUrl);
       }
 
-      return { status: 'failure', wsUrl, message: 'Check proxy settings', 'profile_id': this.profile_id };
+      return {
+        status: "failure",
+        wsUrl,
+        message: "Check proxy settings",
+        profile_id: this.profile_id,
+      };
     }
 
-    const remoteOrbitaUrlWithoutProtocol = remoteOrbitaUrl.replace('https://', '');
-    wsUrl = wsUrl.replace('ws://', 'wss://').replace('127.0.0.1', remoteOrbitaUrlWithoutProtocol);
+    const remoteOrbitaUrlWithoutProtocol = remoteOrbitaUrl.replace(
+      "https://",
+      ""
+    );
+    wsUrl = wsUrl
+      .replace("ws://", "wss://")
+      .replace("127.0.0.1", remoteOrbitaUrlWithoutProtocol);
 
     return wsUrl;
   }
 
   async stopRemote() {
     debug(`stopRemote ${this.profile_id}`);
-    const profileResponse = await requests.delete(`${API_URL}/browser/${this.profile_id}/web`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-    });
+    const profileResponse = await requests.delete(
+      `${API_URL}/browser/${this.profile_id}/web`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.access_token}`,
+          "User-Agent": "gologin-api",
+        },
+      }
+    );
 
     console.log(`stopRemote ${profileResponse.body}`);
     if (profileResponse.body) {
@@ -1499,16 +1767,24 @@ export class GoLogin {
 
   getAvailableFonts() {
     return fontsCollection
-      .filter(elem => elem.fileNames)
-      .map(elem => elem.name);
+      .filter((elem) => elem.fileNames)
+      .map((elem) => elem.name);
   }
 
   async changeProfileResolution(resolution) {
-    return updateProfileResolution(this.profile_id, this.access_token, resolution);
+    return updateProfileResolution(
+      this.profile_id,
+      this.access_token,
+      resolution
+    );
   }
 
   async changeProfileUserAgent(userAgent) {
-    return updateProfileUserAgent(this.profile_id, this.access_token, userAgent);
+    return updateProfileUserAgent(
+      this.profile_id,
+      this.access_token,
+      userAgent
+    );
   }
 
   async changeProfileProxy(proxyData) {