gologin 1.0.52 → 1.0.56

package/browser-user-data-manager.js

@@ -2,7 +2,7 @@ const path = require('path');
 const os = require('os');
 const request = require('requestretry');
 const { rmdirSync, createWriteStream } = require('fs');
-const { access, readFile, writeFile, mkdir, readdir, copyFile } = require('fs').promises;
+const { access, readFile, writeFile, mkdir, readdir, copyFile, rename } = require('fs').promises;
 const crypto = require('crypto');
 
 const fontsCollection = require('./fonts');
@@ -14,6 +14,9 @@ const HOMEDIR = os.homedir();
 const BROWSER_PATH = path.join(HOMEDIR, '.gologin', 'browser');
 const OS_PLATFORM = process.platform;
 const DEFAULT_ORBITA_EXTENSIONS_NAMES = ['Google Hangouts', 'Chromium PDF Viewer', 'CryptoTokenExtension', 'Web Store'];
+const GOLOGIN_BASE_FOLDER_NAME = '.gologin';
+const GOLOGIN_TEST_FOLDER_NAME = '.gologin_test';
+const osPlatform = process.platform;
 
 class BrowserUserDataManager {
   static downloadCookies({ profileId, ACCESS_TOKEN, API_BASE_URL }) {
@@ -119,7 +122,7 @@ class BrowserUserDataManager {
     await writeFile(path.join(defaultFolderPath, 'fonts_config'), result);
   }
 
-  static setExtPathsAndRemoveDeleted(settings = {}, profileExtensionsCheckRes = []) {
+  static setExtPathsAndRemoveDeleted(settings = {}, profileExtensionsCheckRes = [], profileId = '') {
     const formattedLocalExtArray = profileExtensionsCheckRes.map((el) => {
       const [extFolderName = ''] = el.split(path.sep).reverse();
       const [originalId] = extFolderName.split('@');
@@ -130,54 +133,54 @@ class BrowserUserDataManager {
       return {
         path: el,
         originalId,
-      }
+      };
     }).filter(Boolean);
 
     const extensionsSettings = settings.extensions?.settings || {};
     const extensionsEntries = Object.entries(extensionsSettings);
 
-    extensionsEntries.forEach((extensionObj) => {
+    const promises = extensionsEntries.map(async (extensionObj) => {
       let [extensionId, currentExtSettings = {}] = extensionObj;
       const extName = currentExtSettings.manifest?.name || '';
       let extPath = currentExtSettings.path || '';
       let originalId = '';
 
       const isExtensionToBeDeleted = ['resources', 'passwords-ext', 'cookies-ext'].some(substring => extPath.includes(substring))
-        || DEFAULT_ORBITA_EXTENSIONS_NAMES.includes(extName);
+        && [GOLOGIN_BASE_FOLDER_NAME, GOLOGIN_TEST_FOLDER_NAME].some(substring => extPath.includes(substring))
+        || DEFAULT_ORBITA_EXTENSIONS_NAMES.includes(extName)
+        && [GOLOGIN_BASE_FOLDER_NAME, GOLOGIN_TEST_FOLDER_NAME].some(substring => extPath.includes(substring));
+
       if (isExtensionToBeDeleted) {
         delete extensionsSettings[extensionId];
+
         return;
       }
 
-      if (os.platform() === 'win32') {
+      if (osPlatform === 'win32') {
         extPath = extPath.replace(/\//g, '\\');
       } else {
         extPath = extPath.replace(/\\/g, '/');
       }
+
       extensionsSettings[extensionId].path = extPath;
 
-      const isExtensionManageable = ['chrome-extensions', 'user-extensions'].some(substring => extPath.includes(substring));
+      const splittedPath = extPath.split(path.sep);
+      const isExtensionManageable = ['chrome-extensions', 'user-extensions'].some(substring => extPath.includes(substring))
+        && [GOLOGIN_BASE_FOLDER_NAME, GOLOGIN_TEST_FOLDER_NAME].some(substring => extPath.includes(substring));
+
       if (isExtensionManageable) {
         const [extFolderName] = extPath.split(path.sep).reverse();
         [originalId] = extFolderName.split('@');
+      } else if (splittedPath.length === 2) {
+        [originalId] = splittedPath;
+      }
+
+      if (isExtensionManageable || splittedPath.length === 2) {
         const isExtensionInProfileSettings = formattedLocalExtArray.find(el => el.path.includes(originalId));
         if (!isExtensionInProfileSettings) {
           delete extensionsSettings[extensionId];
-          return;
-        }
 
-        if (!currentExtSettings.manifest?.key) {
-          const hexEncodedPath = crypto.createHash('sha256').update(extPath).digest('hex');
-          const newId = hexEncodedPath.split('').slice(0, 32).map(symbol => extIdEncoding[symbol]).join('');
-          delete extensionsSettings[extensionId];
-
-          extensionsSettings[newId] = currentExtSettings;
-          extensionId = newId;
-        }
-      } else {
-        const splittedPath = extPath.split(path.sep);
-        if (splittedPath.length === 2) {
-          [originalId] = splittedPath
+          return;
         }
       }
 
@@ -186,10 +189,28 @@ class BrowserUserDataManager {
         return;
       }
 
-      extensionsSettings[extensionId].path = localExtObj?.path || '';
+      const initialExtName = extensionId;
+
+      extensionId = await this.recalculateId({
+        localExtObj, extensionId, extensionsSettings, currentExtSettings,
+      });
+
+      if (initialExtName !== extensionId) {
+        const profilePath = path.join(os.tmpdir(), `gologin_profile_${profileId}`);
+        const extSyncFolder = path.join(profilePath, 'Default', 'Sync Extension Settings', initialExtName);
+        const newSyncFolder = path.join(profilePath, 'Default', 'Sync Extension Settings', extensionId);
+
+        await rename(extSyncFolder, newSyncFolder).catch(() => null);
+      }
+
+      if (localExtObj.path.endsWith('.zip')) {
+        localExtObj.path = localExtObj.path.replace('.zip', '');
+      }
+
+      extensionsSettings[extensionId].path = localExtObj.path || '';
     });
 
-    return extensionsSettings;
+    return Promise.all(promises).then(() => extensionsSettings);
   }
 
   static async setOriginalExtPaths(settings = {}, originalExtensionsFolder = '') {
@@ -244,6 +265,48 @@ class BrowserUserDataManager {
 
     return extensionsSettings;
   }
+
+  static async recalculateId({ localExtObj, extensionId, extensionsSettings, currentExtSettings }) {
+    if (currentExtSettings.manifest?.key) {
+      return extensionId;
+    }
+
+    const manifestFilePath = path.join(localExtObj.path, 'manifest.json');
+    const manifestString = await readFile(manifestFilePath, { encoding: 'utf8' }).catch(() => ({}));
+
+    if (!manifestString) {
+      return extensionId;
+    }
+
+    let manifestObject;
+    try {
+      manifestObject = JSON.parse(manifestString);
+    } catch {
+      return extensionId;
+    }
+
+    if (manifestObject.key) {
+      return extensionId;
+    }
+
+    let encoding = 'utf8';
+    if (osPlatform === 'win32') {
+      encoding = 'utf16le';
+    }
+
+    const extPathToEncode = Buffer.from(localExtObj.path, encoding);
+
+    const hexEncodedPath = crypto.createHash('sha256').update(extPathToEncode).digest('hex');
+    const newId = hexEncodedPath.split('').slice(0, 32).map(symbol => extIdEncoding[symbol]).join('');
+    if (extensionId !== newId) {
+      delete extensionsSettings[extensionId];
+
+      extensionsSettings[newId] = currentExtSettings;
+      extensionId = newId;
+    }
+
+    return extensionId;
+  }
 }
 
 const extIdEncoding = {

package/common.js

@@ -0,0 +1,23 @@
+const path = require('path');
+
+const ExtensionsExtractor = require('./extensions-extractor');
+const os = require('os');
+
+const HOMEDIR = os.homedir();
+const CHROME_EXT_DIR_NAME = 'chrome-extensions';
+const EXTENSIONS_PATH = path.join(HOMEDIR, '.gologin', 'extensions');
+const CHROME_EXTENSIONS_PATH = path.join(EXTENSIONS_PATH, CHROME_EXT_DIR_NAME);
+const USER_EXTENSIONS_PATH = path.join(HOMEDIR, '.gologin', 'extensions', 'user-extensions');
+
+const composeExtractionPromises = (filteredArchives, destPath = CHROME_EXTENSIONS_PATH) => (
+  filteredArchives.map((extArchivePath) => {
+    const [archiveName = ''] = extArchivePath.split(path.sep).reverse();
+    const [destFolder] = archiveName.split('.');
+    return ExtensionsExtractor.extractExtension(extArchivePath, path.join(destPath, destFolder))
+      .then(() => ExtensionsExtractor.deleteExtensionArchive(extArchivePath))
+  })
+);
+
+module.exports.composeExtractionPromises = composeExtractionPromises;
+module.exports.USER_EXTENSIONS_PATH = USER_EXTENSIONS_PATH;
+module.exports.CHROME_EXTENSIONS_PATH = CHROME_EXTENSIONS_PATH;

package/extensions-manager.js

@@ -1,28 +1,23 @@
 const path = require('path');
 const request = require('requestretry').defaults({ timeout: 60000 });
 const fs = require('fs');
-const { mkdir, readdir, rmdir } = require('fs').promises;
-const os = require('os');
+const { mkdir, readdir, rmdir, unlink } = require('fs').promises;
 
-const  ExtensionsExtractor = require('./extensions-extractor');
+const UserExtensionsManager = require('./user-extensions-manager');
+const { composeExtractionPromises, CHROME_EXTENSIONS_PATH, USER_EXTENSIONS_PATH } = require('./common');
 
-const HOMEDIR = os.homedir();
-const CHROME_EXT_DIR_NAME = 'chrome-extensions';
-const EXTENSIONS_PATH = path.join(HOMEDIR, '.gologin', 'extensions');
-const CHROME_EXTENSIONS_PATH = path.join(EXTENSIONS_PATH, CHROME_EXT_DIR_NAME);
 const EXTENSION_URL = 'https://clients2.google.com/service/update2/crx?response=redirect&acceptformat=crx2,crx3&x=id%3D{ext_id}%26uc&prodversion=97.0.4692.71';
 
-class ExtensionsManager {
-  #USER_AGENT = '';
-  #API_BASE_URL = '';
-  #ACCESS_TOKEN = '';
+class ExtensionsManager extends UserExtensionsManager {
   #existedChromeExtensions = [];
   #inited = false;
   #useLocalExtStorage = false;
+  #useCookiesExt = false;
   #deleteProfileExtFolders = false;
-  #deleteWidevineCdmFolder = false;
+  #extensionsUpdating = true;
 
   constructor() {
+    super();
     if (!ExtensionsManager.instance) {
       ExtensionsManager.instance = this;
     }
@@ -30,49 +25,42 @@ class ExtensionsManager {
     return ExtensionsManager.instance;
   }
 
-  get isInited() { return this.#inited }
-  get useLocalExtStorage() { return this.#useLocalExtStorage }
-  get deleteProfileExtFolders() { return this.#deleteProfileExtFolders }
-  get deleteWidevineCdmFolder() { return this.#deleteWidevineCdmFolder }
-
-  set userAgent(userAgent) {
-    if (!userAgent) {
-      return;
-    }
-
-    this.#USER_AGENT = userAgent;
-  }
-
-  set accessToken(accessToken) {
-    if (!accessToken) {
-      return;
-    }
-
-    this.#ACCESS_TOKEN = accessToken;
-  }
-
-  set apiUrl(apiUrl) {
-    if (!apiUrl) {
-      return;
-    }
-
-    this.#API_BASE_URL = apiUrl;
-  }
-
-  init() {
+  async init() {
     if (this.#inited) {
       return Promise.resolve();
     }
 
-    return mkdir(CHROME_EXTENSIONS_PATH, { recursive: true })
-      .then(() => readdir(CHROME_EXTENSIONS_PATH))
-      .then(filesList => {
-        this.#existedChromeExtensions = filesList;
-        this.#inited = true;
-      })
-      .catch((e) => console.log('ExtensionsManager init error:', e));
+    const promises = [
+      mkdir(CHROME_EXTENSIONS_PATH, { recursive: true })
+        .then(() => readdir(CHROME_EXTENSIONS_PATH))
+        .then(filesList => {
+          this.#existedChromeExtensions = filesList.filter(extPath => !extPath.includes('.zip'));
+          return filesList.map(fileName => fileName.includes('.zip') ?
+            unlink(path.join(CHROME_EXTENSIONS_PATH, fileName)) :
+            Promise.resolve());
+        })
+        .then(promisesToDelete => Promise.all(promisesToDelete))
+        .catch((e) => console.log('ExtensionsManager init error:', e)),
+      mkdir(USER_EXTENSIONS_PATH, { recursive: true })
+        .then(() => readdir(USER_EXTENSIONS_PATH))
+        .then(filesList => {
+          this.existedUserExtensions = filesList.filter(extPath => !extPath.includes('.zip'));
+          return filesList.map(fileName => fileName.includes('.zip') ?
+            unlink(path.join(USER_EXTENSIONS_PATH, fileName)) :
+            Promise.resolve());
+        })
+        .then((promisesToDelete) => Promise.all(promisesToDelete))
+        .catch((e) => console.log('error creating user extensions folder:', e)),
+    ]
+
+    return Promise.all(promises).then(() => this.#inited = true);
   }
 
+  get isInited() { return this.#inited }
+  get useLocalExtStorage() { return this.#useLocalExtStorage }
+  get deleteProfileExtFolders() { return this.#deleteProfileExtFolders }
+  get useCookiesExt() { return this.#useCookiesExt }
+
   get existedChromeExtensionsList() {
     return this.#existedChromeExtensions;
   }
@@ -83,20 +71,25 @@ class ExtensionsManager {
     }
 
     const extensionsToDownload = this.#getExtensionsToDownload(profileExtensions);
-    if (!extensionsToDownload) {
-      return [];
-    }
 
     const downloadedArchives = await this.downloadChromeExtensions(extensionsToDownload);
     const filteredArchives = downloadedArchives.filter(Boolean);
-    const promises = composeExtractionPromises(filteredArchives);
 
-    await Promise.all(promises);
+    if (filteredArchives.length) {
+      const [downloadedFolders] = filteredArchives.map(archivePath => archivePath.split(path.sep).reverse());
+      this.#existedChromeExtensions = [...this.#existedChromeExtensions, ...downloadedFolders];
+
+      const promises = composeExtractionPromises(filteredArchives);
+
+      await Promise.all(promises);
+    }
+
     return this.getExtensionsStrToIncludeAsOrbitaParam(profileExtensions);
   }
 
   #getExtensionsToDownload(profileExtensions) {
-    const existedOriginalIds = this.#existedChromeExtensions.map((val) => {
+    const existedExtensionsFolders = [...this.#existedChromeExtensions, ...this.existedUserExtensions]
+    const existedOriginalIds = existedExtensionsFolders.map((val) => {
       const [originalId] = val.split('@');
       return originalId;
     });
@@ -159,10 +152,11 @@ class ExtensionsManager {
   }
 
   async getExtensionsPolicies() {
-    const globalExtConfig = await request.get(`${this.#API_BASE_URL}/gologin-settings/chrome_ext_policies`, {
+    const globalExtConfig = await request.get(`${this.apiBaseUrl}/gologin-settings/chrome_ext_policies`, {
       headers: {
-        Authorization: `Bearer ${this.#ACCESS_TOKEN}`,
-        'user-agent': this.#USER_AGENT,
+        Authorization: `Bearer ${this.accessToken}`,
+        'user-agent': this.userAgent,
+        'x-two-factor-token': this.twoFaKey || '',
       },
       json: true,
       maxAttempts: 2,
@@ -175,40 +169,12 @@ class ExtensionsManager {
     const {
       useLocalExtStorage = false,
       deleteProfileExtFolders = false,
-      deleteWidevineCdmFolder = false,
+      useCookiesExt = true,
     } = chromeExtPolicies;
 
     this.#useLocalExtStorage = useLocalExtStorage;
     this.#deleteProfileExtFolders = deleteProfileExtFolders;
-    this.#deleteWidevineCdmFolder = deleteWidevineCdmFolder;
-  }
-
-  async getExtensionsStrToIncludeAsOrbitaParam(profileExtensions = []) {
-    if (!(Array.isArray(profileExtensions) && profileExtensions.length)) {
-      return [];
-    }
-
-    const chromeExtList = await readdir(CHROME_EXTENSIONS_PATH);
-    if (!chromeExtList) {
-      return [];
-    }
-
-    const formattedIdsList = chromeExtList.map((el) => {
-      const [originalId] = el.split('@');
-      return {
-        originalId,
-        folderName: el,
-      };
-    });
-
-    return profileExtensions.map((el) => {
-      const extExisted = formattedIdsList.find(chromeExtPathElem => chromeExtPathElem.originalId === el);
-      if (!extExisted) {
-        return '';
-      }
-
-      return path.join(CHROME_EXTENSIONS_PATH, extExisted.folderName);
-    }).filter(Boolean);
+    this.#useCookiesExt = useCookiesExt;
   }
 
   async updateExtensions() {
@@ -220,7 +186,7 @@ class ExtensionsManager {
     const oldFolders = [];
 
     const versionCheckPromises = fileList.map(async (extension) => {
-      if (!extension.includes('@')) {
+      if (!extension.includes('@') || extension.includes('.zip')) {
         return '';
       }
 
@@ -247,7 +213,70 @@ class ExtensionsManager {
       rmdir(folder, { recursive: true, maxRetries: 3 }).catch(() => {})
     ));
 
-    return Promise.all(removeFoldersPromises);
+    await Promise.all(removeFoldersPromises).then(() => this.#extensionsUpdating = false);
+  }
+
+
+  async checkLocalExtensions() {
+    if (this.#extensionsUpdating || !this.accessToken) {
+      return;
+    }
+
+    const fileList = await readdir(CHROME_EXTENSIONS_PATH).catch(() => []);
+    if (!fileList.length) {
+      return;
+    }
+
+    const extensionsIds = fileList.filter(folderName => folderName.includes('@') && !folderName.includes('.zip'))
+      .map(folderName => {
+        const [name] = folderName.split('@');
+        return name;
+      });
+
+    if (!extensionsIds.length) {
+      return;
+    }
+
+    this.insertExtensionsToDb(extensionsIds);
+  }
+
+  async insertExtensionsToDb(extensionsIds, pathToExtensions = CHROME_EXTENSIONS_PATH) {
+    if (!extensionsIds?.length) {
+      return;
+    }
+
+    const checkResponse = await request(`${this.apiBaseUrl}/extensions/check`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        'user-agent': this.userAgent,
+        'x-two-factor-token': this.twoFaKey || '',
+      },
+      body: {
+        extensionsIds,
+      },
+      json: true,
+    });
+    const { extensionsToAdd = [] } = checkResponse.body;
+
+    if (!extensionsToAdd.length) {
+      return;
+    }
+
+    const extensionsToUpdate = await this.getExtensionsNameAndImage(extensionsToAdd, pathToExtensions);
+
+    request(`${this.apiBaseUrl}/extensions/create`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        'user-agent': this.userAgent,
+        'x-two-factor-token': this.twoFaKey || '',
+      },
+      body: {
+        extensionsInfo: extensionsToUpdate,
+      },
+      json: true,
+    });
   }
 
   getExtensionsToInstall(extensionsFromPref, extensionsFromDB) {
@@ -330,15 +359,6 @@ const getExtVersion = (metadata) => {
   return splitExtName.join('_');
 };
 
-const composeExtractionPromises = (filteredArchives) => (
-  filteredArchives.map((extArchivePath) => {
-    const [archiveName = ''] = extArchivePath.split(path.sep).reverse();
-    const [destFolder] = archiveName.split('.');
-    return ExtensionsExtractor.extractExtension(extArchivePath, path.join(CHROME_EXTENSIONS_PATH, destFolder))
-      .then(() => ExtensionsExtractor.deleteExtensionArchive(extArchivePath))
-  })
-);
-
 module.exports = ExtensionsManager;
 
 

package/gologin.js

@@ -23,6 +23,7 @@ const ExtensionsManager = require('./extensions-manager');
 
 const SEPARATOR = path.sep;
 const API_URL = 'https://api.gologin.com';
+// const API_URL = 'http://localhost:3002';
 const OS_PLATFORM = process.platform;
 
 // process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = 0;
@@ -402,9 +403,11 @@ class GoLogin {
     let preferences = JSON.parse(preferences_raw.toString());
     let proxy = _.get(profile, 'proxy');
     let name = _.get(profile, 'name');
-    const chromeExtensions = _.get(profile, 'chromeExtensions');
+    const chromeExtensions = _.get(profile, 'chromeExtensions') || [];
+    const userChromeExtensions = _.get(profile, 'userChromeExtensions') || [];
+    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
 
-    if (chromeExtensions && chromeExtensions.length) {
+    if (allExtensions.length) {
       const ExtensionsManagerInst = new ExtensionsManager();
       ExtensionsManagerInst.apiUrl = API_URL;
       await ExtensionsManagerInst.init()
@@ -416,15 +419,31 @@ class GoLogin {
       let profileExtensionsCheckRes = [];
 
       if (ExtensionsManagerInst.useLocalExtStorage) {
-        profileExtensionsCheckRes = await ExtensionsManagerInst.checkChromeExtensions(chromeExtensions).catch((e) => {
-          console.log('checkChromeExtensions error: ', e);
-          return [];
-        });
+        const promises = [
+          ExtensionsManagerInst.checkChromeExtensions(allExtensions)
+            .then(res => ({ profileExtensionsCheckRes: res }))
+            .catch((e) => {
+            console.log('checkChromeExtensions error: ', e);
+            return { profileExtensionsCheckRes: [] };
+          }),
+          ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions)
+            .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 = BrowserUserDataManager.setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes);
+        extSettings = await BrowserUserDataManager.setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes, this.profile_id);
       } else {
         const originalExtensionsFolder = path.join(profilePath, 'Default', 'Extensions');
         extSettings = await BrowserUserDataManager.setOriginalExtPaths(preferences, originalExtensionsFolder);
@@ -484,6 +503,7 @@ class GoLogin {
     };
     profile.geoLocation = this.getGeolocationParams(profileGeolocation, tzGeoLocation);
     profile.name = name;
+    profile.name_base64 = Buffer.from(name).toString('base64');
     profile.profile_id = this.profile_id;
 
     profile.webRtc = {
@@ -821,7 +841,7 @@ class GoLogin {
       if (Array.isArray(this.extra_params) && this.extra_params.length) {
         params = params.concat(this.extra_params);
       }
-
+      console.log(params)
       const child = execFile(ORBITA_BROWSER, params, {env});
       // const child = spawn(ORBITA_BROWSER, params, { env, shell: true });
       child.stdout.on('data', (data) => debug(data.toString()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin",
-  "version": "1.0.52",
+  "version": "1.0.56",
   "description": "A high-level API to control Orbita browser over GoLogin API",
   "main": "./gologin.js",
   "repository": {

package/user-extensions-manager.js

@@ -0,0 +1,408 @@
+const path = require('path');
+const fs = require('fs');
+const { readdir, rmdir, readFile, stat, mkdir, copyFile } = require('fs').promises;
+const request = require('requestretry').defaults({ timeout: 60000 });
+const zipdir = require('zip-dir');
+
+const ExtensionsExtractor = require('./extensions-extractor');
+const { composeExtractionPromises, CHROME_EXTENSIONS_PATH, USER_EXTENSIONS_PATH } = require('./common');
+
+const MAX_FILE_SIZE = 80 * 1024 * 1024;
+const MAX_FILE_SIZE_MB = MAX_FILE_SIZE / 1024 / 1024;
+
+class UserExtensionsManager {
+  #existedUserExtensions = [];
+  #API_BASE_URL = '';
+  #ACCESS_TOKEN = '';
+  #USER_AGENT = '';
+  #TWO_FA_KEY = '';
+
+  set userAgent(userAgent) {
+    if (!userAgent) {
+      return;
+    }
+
+    this.#USER_AGENT = userAgent;
+  }
+
+  set accessToken(accessToken) {
+    if (!accessToken) {
+      return;
+    }
+
+    this.#ACCESS_TOKEN = accessToken;
+  }
+
+  set twoFaKey(twoFaKey) {
+    if (!twoFaKey) {
+      return;
+    }
+
+    this.#TWO_FA_KEY = twoFaKey;
+  }
+
+  set apiUrl(apiUrl) {
+    if (!apiUrl) {
+      return;
+    }
+
+    this.#API_BASE_URL = apiUrl;
+  }
+
+  get apiBaseUrl() {
+    return this.#API_BASE_URL;
+  }
+
+  get existedUserExtensions() {
+    return this.#existedUserExtensions;
+  }
+
+  get accessToken() {
+    return this.#ACCESS_TOKEN;
+  }
+
+  get twoFaKey() {
+    return this.#TWO_FA_KEY;
+  }
+
+  get userAgent() {
+    return this.#USER_AGENT;
+  }
+
+  set existedUserExtensions(fileList) {
+    if (!fileList) {
+      return;
+    }
+
+    this.#existedUserExtensions = fileList;
+  }
+
+  async addCustomExtension(pathToFiles) {
+    try {
+      const filesSize = await checkFileSizeSync(pathToFiles);
+      const isZip = pathToFiles.endsWith('.zip');
+
+      if (filesSize > MAX_FILE_SIZE) {
+        throw new Error(`The maximum file size is ${MAX_FILE_SIZE_MB}MB`);
+      }
+
+      const customId = this.generateExtensionId();
+
+      if (isZip) {
+        const pathToExtract = path.join(USER_EXTENSIONS_PATH, customId);
+        await ExtensionsExtractor.extractExtension(pathToFiles, pathToExtract);
+        pathToFiles = pathToExtract;
+      }
+
+      let fileList = (await readdir(pathToFiles).catch(() => ['cantReadError']))
+        .filter(folderContent => folderContent !== '.DS_Store');
+
+      if (fileList.length === 1 && !fileList.includes('cantReadError')) {
+        const isFolder = (await stat(pathToFiles)).isDirectory();
+        if (isFolder) {
+          const [folderName] = fileList;
+          pathToFiles = path.join(pathToFiles, folderName);
+          fileList = await readdir(pathToFiles).catch(() => ['cantReadError']);
+        }
+      }
+
+      if (fileList.includes('cantReadError')) {
+        throw new Error('Can\'t access folder');
+      }
+
+      if (!fileList.includes('manifest.json')) {
+        if (isZip) {
+          rmdir(pathToFiles);
+        }
+        throw new Error('There is no manifest.json in the extension folder');
+      }
+
+      if (!isZip) {
+        const destPath = path.join(USER_EXTENSIONS_PATH, customId)
+        await copyFolder(pathToFiles, destPath).catch(() => {
+          throw new Error('Something went wrong coping your folder');
+        });
+      }
+
+      const [nameIconId] = await this.getExtensionsNameAndImage([customId], USER_EXTENSIONS_PATH);
+
+      if (!nameIconId) {
+        throw new Error('Something went wrong. Please try again later');
+      }
+
+      const dbResult = await request(`${this.#API_BASE_URL}/extensions/create_user_extension`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.#ACCESS_TOKEN}`,
+          'user-agent': this.#USER_AGENT,
+          'x-two-factor-token': this.#TWO_FA_KEY || '',
+        },
+        body: {
+          extensionInfo: nameIconId,
+        },
+        json: true,
+      });
+      // if success - there is no body
+      if (dbResult.body) {
+        throw new Error('Something went wrong inserting your data to database');
+      }
+
+      const fileBuffer = await zipdir(pathToFiles).catch(() => null);
+      if (!fileBuffer) {
+        throw new Error('Something went wrong. Please try again later');
+      }
+
+      const signedUrl = await request.get(`${this.#API_BASE_URL}/extensions/upload_url?extId=${customId}`, {
+        headers: {
+          Authorization: `Bearer ${this.#ACCESS_TOKEN}`,
+          'user-agent': this.#USER_AGENT,
+          'x-two-factor-token': this.#TWO_FA_KEY || '',
+        },
+        maxAttempts: 3,
+        retryDelay: 2000,
+        timeout: 10 * 1000,
+        fullResponse: false,
+      });
+
+      const uploadResponse = await request.put(signedUrl, {
+        headers: {
+          'Content-Type': 'application/zip',
+          'Content-Length': Buffer.byteLength(fileBuffer),
+        },
+        body: fileBuffer,
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+        maxAttempts: 3,
+        retryDelay: 2000,
+        timeout: 30 * 1000,
+        fullResponse: true,
+      });
+      // if success - there is no body, in case of error - there will be an error in the body
+      if (uploadResponse.body) {
+        throw new Error('Your extension is added locally but we couldn\'t upload it to the cloud');
+      }
+
+      return {
+        status: 'success',
+        message: nameIconId,
+      }
+    } catch (e) {
+      return {
+        status: 'error',
+        message: e.message,
+      }
+    }
+  }
+
+  checkLocalUserChromeExtensions = async (userChromeExtensions) => {
+    if (!userChromeExtensions.length) {
+      return;
+    }
+
+    const extensionsToDownloadPaths = await request.post(`${this.#API_BASE_URL}/extensions/user_chrome_extensions_paths`, {
+      json: true,
+      fullResponse: false,
+      headers: {
+        Authorization: `Bearer ${this.#ACCESS_TOKEN}`,
+        'user-agent': this.#USER_AGENT,
+        'x-two-factor-token': this.#TWO_FA_KEY || '',
+      },
+      body: {
+        existedUserChromeExtensions: this.#existedUserExtensions,
+      }
+    }) || [];
+
+    const extensionsToDownloadPathsFiltered =
+      extensionsToDownloadPaths.filter(extPath => userChromeExtensions.some(extId => extPath.includes(extId)));
+
+    if (!extensionsToDownloadPathsFiltered.length) {
+      return this.getExtensionsStrToIncludeAsOrbitaParam(userChromeExtensions, USER_EXTENSIONS_PATH);
+    }
+
+    const promises = extensionsToDownloadPathsFiltered.map(async awsPath => {
+      const [basePath] = awsPath.split('?');
+      const [extId] = basePath.split('/').reverse();
+      const zipPath = `${path.join(USER_EXTENSIONS_PATH, extId)}.zip`;
+      const archiveZip = fs.createWriteStream(zipPath);
+
+      await request(awsPath, {
+        retryDelay: 2 * 1000,
+        maxAttempts: 3,
+      }).pipe(archiveZip);
+
+      await new Promise(r => archiveZip.on('close', () => r()));
+      return zipPath;
+    });
+
+    const zipPaths = await Promise.all(promises).catch(() => []);
+
+    if (!zipPaths) {
+      return this.getExtensionsStrToIncludeAsOrbitaParam(userChromeExtensions, USER_EXTENSIONS_PATH);
+    }
+
+    const extractionPromises = composeExtractionPromises(zipPaths, USER_EXTENSIONS_PATH);
+    const isExtensionsExtracted = await Promise.all(extractionPromises).catch(() => 'error');
+
+    if (isExtensionsExtracted !== 'error') {
+      const [downloadedFolders] = zipPaths.map(archivePath => archivePath.split(path.sep).reverse());
+      this.#existedUserExtensions = [...this.#existedUserExtensions, ...downloadedFolders];
+    }
+
+    return this.getExtensionsStrToIncludeAsOrbitaParam(userChromeExtensions, USER_EXTENSIONS_PATH);
+  }
+
+  async getExtensionsStrToIncludeAsOrbitaParam(profileExtensions = [], folderPath = CHROME_EXTENSIONS_PATH) {
+    if (!(Array.isArray(profileExtensions) && profileExtensions.length)) {
+      return [];
+    }
+
+    const folders = await readdir(folderPath).then(folderNames => folderNames.map(folderName => path.join(folderPath, folderName)));
+
+    if (!folders.length) {
+      return [];
+    }
+
+    const formattedIdsList = folders.map((el) => {
+      const [folderName] = el.split(path.sep).reverse();
+      const [originalId] = folderName.split('@');
+      return {
+        originalId,
+        path: el,
+      };
+    });
+
+    return profileExtensions.map((el) => {
+      const extExisted = formattedIdsList.find(chromeExtPathElem => chromeExtPathElem.originalId === el);
+
+      if (!extExisted) {
+        return '';
+      }
+
+      return extExisted.path;
+    }).filter(Boolean);
+  }
+
+  async getExtensionsNameAndImage(extensionsIds, pathToExtensions) {
+    const isCheckLocalFiles = [CHROME_EXTENSIONS_PATH, USER_EXTENSIONS_PATH].includes(pathToExtensions);
+    const extensionFolderNames = await readdir(pathToExtensions).catch(() => {});
+    const filteredExtensionFolderNames = extensionFolderNames.filter(extensionFolder => extensionsIds.some(extensionId => !extensionFolder.includes('.zip') && extensionFolder.includes(extensionId)));
+
+    if (!filteredExtensionFolderNames.length) {
+      return;
+    }
+
+    const namesPromise = extensionsIds.map(async (extensionsId) => {
+      const folderName = filteredExtensionFolderNames.find(folderName => folderName.includes(extensionsId));
+
+      if (!folderName) {
+        return;
+      }
+
+      let pathToExtensionsFolder = [pathToExtensions, folderName];
+      if (!isCheckLocalFiles) {
+        const [extensionVersion] = await readdir(path.join(pathToExtensions, folderName));
+        pathToExtensionsFolder = [pathToExtensions, folderName, extensionVersion];
+      }
+
+      const manifestPath = path.join(...pathToExtensionsFolder, 'manifest.json');
+      const manifestString = await readFile(manifestPath, 'utf8').catch(() => '');
+      if (!manifestString) {
+        return;
+      }
+
+      const manifestObject = JSON.parse(manifestString);
+      let name;
+      if (manifestObject.name.includes('__MSG')) {
+        const manifestName = manifestObject.name || '';
+        const fieldNameInLocale = manifestName.replace(/__/g, '').split('MSG_')[1];
+        const localePath = path.join(...pathToExtensionsFolder, '_locales', manifestObject.default_locale, 'messages.json');
+        const localeString = await readFile(localePath, 'utf8').catch(() => {});
+
+        try {
+          const parsedLocale = JSON.parse(localeString.trim());
+          name = parsedLocale[fieldNameInLocale].message;
+        } catch (e) {}
+      } else {
+        name = manifestObject.name;
+      }
+
+      if (!name) {
+        return;
+      }
+
+      const iconObject = manifestObject.icons;
+      let iconPath = manifestObject.browser_action?.default_icon;
+      if (iconObject) {
+        iconPath = iconObject['128'];
+      }
+
+      let iconBSON = '';
+      if (iconPath) {
+        const iconPathFull = path.join(...pathToExtensionsFolder, iconPath);
+        iconBSON = await readFile(iconPathFull, 'base64').catch(() => {});
+      }
+
+      return {
+        name,
+        extId: extensionsId,
+        iconBinary: iconBSON,
+      };
+    });
+
+    const extensionsArray = await Promise.all(namesPromise);
+    return extensionsArray.filter(Boolean);
+  }
+
+  generateExtensionId() {
+    let result = '';
+    let extensionIdLength = 32;
+    const characters = 'abcdefghijklmnopqrstuvwxyz';
+    const charactersLength = characters.length;
+    while (extensionIdLength--) {
+      result += characters.charAt(Math.floor(Math.random() *
+        charactersLength));
+    }
+    return result;
+  }
+}
+
+const checkFileSizeSync = async (pathToFile) => {
+  try {
+    const [fileName] = pathToFile.split(path.sep).reverse();
+    if (fileName === '.DS_Store') {
+      return 0;
+    }
+
+    const fileStats = await stat(pathToFile);
+    if (!fileStats.isDirectory()) {
+      return fileStats.size;
+    }
+
+    const files = await readdir(pathToFile);
+    const promises = files.map(async file => checkFileSizeSync(path.join(pathToFile, file)));
+
+    return (await Promise.all(promises)).reduce((result, value) => result + value, 0);
+  } catch {
+    return -1;
+  }
+};
+
+const copyFolder = async (fromPath, destPath) => {
+  const stats = await stat(fromPath);
+
+  if (!stats.isDirectory()) {
+    return copyFile(fromPath, destPath);
+  }
+
+  await mkdir(destPath, { recursive: true }).catch(() => null);
+  const files = await readdir(fromPath);
+  const promises = files.map(async file => {
+    await mkdir(destPath, { recursive: true }).catch(() => null);
+
+    return copyFolder(path.join(fromPath, file), path.join(destPath, file));
+  });
+
+  return Promise.all(promises);
+};
+
+module.exports = UserExtensionsManager;