gologin-commonjs 2.1.1

package/dist/src/browser/browser-checker.js

@@ -0,0 +1,336 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.BrowserChecker = void 0;
+var _child_process = require("child_process");
+var _decompress = _interopRequireDefault(require("decompress"));
+var _decompressUnzip = _interopRequireDefault(require("decompress-unzip"));
+var _fs = require("fs");
+var _https = require("https");
+var _os = require("os");
+var _path = require("path");
+var _progress = _interopRequireDefault(require("progress"));
+var _readline = require("readline");
+var _util = _interopRequireDefault(require("util"));
+var _utils = require("../utils/utils.js");
+var _common = require("../utils/common.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const exec = _util.default.promisify(_child_process.exec);
+const {
+  access,
+  mkdir,
+  readdir,
+  rmdir,
+  unlink,
+  copyFile,
+  readlink,
+  symlink,
+  lstat,
+  rename,
+  writeFile
+} = _fs.promises;
+const PLATFORM = process.platform;
+const ARCH = process.arch;
+const VERSION_FILE = 'latest-version.txt';
+const WIN_FOLDERSIZE_FILE = 'foldersize.txt';
+const WIN_FOLDERSIZE_FILE_LINK = `https://orbita-browser-windows.gologin.com/${WIN_FOLDERSIZE_FILE}`;
+const BROWSER_ARCHIVE_NAME = `orbita-browser-latest.${PLATFORM === 'win32' ? 'zip' : 'tar.gz'}`;
+const MAC_HASH_FILE = 'hashfile.mtree';
+const DEB_HASH_FILE = 'hashfile.txt';
+const WIN_HASH_FILE = DEB_HASH_FILE;
+const MAC_HASHFILE_LINK = `https://orbita-browser-mac.gologin.com/${MAC_HASH_FILE}`;
+const DEB_HASHFILE_LINK = `https://orbita-browser-linux.gologin.com/${DEB_HASH_FILE}`;
+const WIN_HASHFILE_LINK = `https://orbita-browser-windows.gologin.com/${WIN_HASH_FILE}`;
+const MAC_ARM_HASHFILE_LINK = `https://orbita-browser-mac-arm.gologin.com/${MAC_HASH_FILE}`;
+const FAIL_SUM_MATCH_MESSAGE = 'hash_sum_not_matched';
+const EXTRACTED_FOLDER = 'extracted-browser';
+class BrowserChecker {
+  #homedir;
+  #browserPath;
+  #executableFilePath;
+  #skipOrbitaHashChecking = false;
+  constructor(skipOrbitaHashChecking) {
+    this.#skipOrbitaHashChecking = skipOrbitaHashChecking;
+    this.#homedir = (0, _os.homedir)();
+    this.#browserPath = (0, _path.join)(this.#homedir, '.gologin', 'browser');
+    let executableFilePath = (0, _path.join)(this.#browserPath, 'orbita-browser', 'chrome');
+    if (PLATFORM === 'darwin') {
+      const orbitaFolderName = (0, _utils.findLatestBrowserVersionDirectory)(this.#browserPath);
+      if (orbitaFolderName === 'error') {
+        throw Error('Orbita folder not found in this directory: ' + this.#browserPath);
+      }
+      executableFilePath = (0, _path.join)(this.#browserPath, orbitaFolderName, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
+    } else if (PLATFORM === 'win32') {
+      executableFilePath = (0, _path.join)(this.#browserPath, 'orbita-browser', 'chrome.exe');
+    }
+    this.#executableFilePath = executableFilePath;
+    // console.log('executableFilePath:', executableFilePath);
+  }
+  async checkBrowser(autoUpdateBrowser = false, checkBrowserUpdate = true) {
+    const browserFolderExists = await access(this.#executableFilePath).then(() => true).catch(() => false);
+    const {
+      latestVersion: browserLatestVersion,
+      browserDownloadUrl
+    } = await this.getLatestBrowserVersion();
+    if (!browserFolderExists) {
+      return this.downloadBrowser(browserLatestVersion, browserDownloadUrl);
+    }
+    const currentVersionReq = await this.getCurrentVersion();
+    const currentVersion = (currentVersionReq?.stdout || '').replace(/(\r\n|\n|\r)/gm, '');
+    if (browserLatestVersion === currentVersion || !checkBrowserUpdate) {
+      return;
+    }
+    if (autoUpdateBrowser) {
+      return this.downloadBrowser(browserLatestVersion, browserDownloadUrl);
+    }
+    return new Promise(resolve => {
+      const rl = (0, _readline.createInterface)(process.stdin, process.stdout);
+      const timeout = setTimeout(() => {
+        console.log(`\nContinue with current ${currentVersion} version.`);
+        resolve();
+      }, 10000);
+      rl.question(`New Orbita ${browserLatestVersion} is available. Update? [y/n] `, answer => {
+        clearTimeout(timeout);
+        rl.close();
+        if (answer && answer[0].toString().toLowerCase() === 'y') {
+          return this.downloadBrowser(browserLatestVersion, browserDownloadUrl).then(() => resolve());
+        }
+        console.log(`Continue with current ${currentVersion} version.`);
+        resolve();
+      });
+    });
+  }
+  async downloadBrowser(latestVersion, browserDownloadUrl) {
+    await this.deleteOldArchives(true);
+    await mkdir(this.#browserPath, {
+      recursive: true
+    });
+    const pathStr = (0, _path.join)(this.#browserPath, BROWSER_ARCHIVE_NAME);
+    await this.downloadBrowserArchive(browserDownloadUrl, pathStr);
+    await this.checkBrowserArchive(pathStr);
+    await this.extractBrowser();
+    await this.checkBrowserSum(latestVersion);
+    console.log('Orbita hash checked successfully');
+    await this.replaceBrowser();
+    await this.addLatestVersion(latestVersion).catch(() => null);
+    await this.deleteOldArchives();
+    console.log('Orbita updated successfully');
+  }
+  addLatestVersion(latestVersion) {
+    return mkdir((0, _path.join)(this.#browserPath, 'orbita-browser', 'version'), {
+      recursive: true
+    }).then(() => writeFile((0, _path.join)(this.#browserPath, 'orbita-browser', 'version', 'latest-version.txt'), latestVersion));
+  }
+  downloadBrowserArchive(link, pathStr) {
+    return new Promise((resolve, reject) => {
+      const writableStream = (0, _fs.createWriteStream)(pathStr);
+      writableStream.on('error', async err => {
+        await unlink(pathStr);
+        reject(err);
+      });
+      writableStream.on('finish', () => resolve());
+      const req = (0, _https.get)(link, {
+        timeout: 15 * 1000
+      }, res => {
+        const len = parseInt(res.headers['content-length'], 10);
+        const formattedLen = len / 1024 / 1024;
+        const bar = new _progress.default('Orbita downloading [:bar] :rate/mps :downloadedMb/:fullMbMB :percent :etas', {
+          complete: '=',
+          incomplete: ' ',
+          width: 30,
+          total: Math.round(formattedLen)
+        });
+        let downloadedMb = 0;
+        res.on('data', chunk => {
+          const formattedChunckLenght = chunk.length / 1024 / 1024;
+          downloadedMb += formattedChunckLenght;
+          bar.tick(formattedChunckLenght, {
+            fullMb: formattedLen.toFixed(2),
+            downloadedMb: downloadedMb.toFixed(2)
+          });
+        });
+        res.on('end', () => {
+          bar.tick(bar.total, {
+            fullMb: formattedLen.toFixed(2),
+            downloadedMb: formattedLen.toFixed(2)
+          });
+          console.log('\nDownload completed');
+          writableStream.end();
+        });
+        res.pipe(writableStream);
+      });
+      req.on('error', err => writableStream.destroy(err));
+      req.end();
+    });
+  }
+  async checkBrowserArchive(pathStr) {
+    console.log('Checking Orbita archive');
+    try {
+      await access(pathStr);
+    } catch (e) {
+      throw new Error('Archive has not been found. Please run script again.');
+    }
+  }
+  async extractBrowser() {
+    console.log('Extracting Orbita');
+    await mkdir((0, _path.join)(this.#browserPath, EXTRACTED_FOLDER), {
+      recursive: true
+    });
+    if (PLATFORM === 'win32') {
+      return (0, _decompress.default)((0, _path.join)(this.#browserPath, BROWSER_ARCHIVE_NAME), (0, _path.join)(this.#browserPath, EXTRACTED_FOLDER), {
+        plugins: [(0, _decompressUnzip.default)()],
+        filter: file => !file.path.endsWith('/')
+      });
+    }
+    return exec(`tar xzf ${(0, _path.join)(this.#browserPath, BROWSER_ARCHIVE_NAME)} --directory ${(0, _path.join)(this.#browserPath, EXTRACTED_FOLDER)}`);
+  }
+  async downloadHashFile(latestVersion) {
+    let hashLink = DEB_HASHFILE_LINK;
+    let resultPath = (0, _path.join)(this.#browserPath, DEB_HASH_FILE);
+    if (PLATFORM === 'darwin') {
+      hashLink = MAC_HASHFILE_LINK;
+      if (ARCH === 'arm64') {
+        hashLink = MAC_ARM_HASHFILE_LINK;
+      }
+      resultPath = (0, _path.join)(this.#browserPath, MAC_HASH_FILE);
+    }
+    if (latestVersion) {
+      const [majorVer] = latestVersion.split('.');
+      hashLink = hashLink.replace('hashfile.', `hashfile-${majorVer}.`);
+    }
+    const writableStream = (0, _fs.createWriteStream)(resultPath);
+    writableStream.on('error', async err => {
+      await unlink(resultPath);
+      throw err;
+    });
+    await new Promise(resolve => (0, _https.get)(hashLink, {
+      timeout: 10 * 1000
+    }, res => {
+      res.on('end', () => {
+        console.log('Hashfile downloading completed');
+        writableStream.end();
+        resolve();
+      });
+      res.pipe(writableStream);
+    }).on('error', err => writableStream.destroy(err)));
+    const hashFile = PLATFORM === 'darwin' ? MAC_HASH_FILE : DEB_HASH_FILE;
+    const hashFilePath = (0, _path.join)(this.#browserPath, hashFile);
+    return access(hashFilePath);
+  }
+  async checkBrowserSum(latestVersion) {
+    if (this.#skipOrbitaHashChecking) {
+      return Promise.resolve();
+    }
+    console.log('Orbita hash checking');
+    if (PLATFORM === 'win32') {
+      return Promise.resolve();
+    }
+    await this.downloadHashFile(latestVersion);
+    if (PLATFORM === 'darwin') {
+      const calculatedHash = await exec(`mtree -p ${(0, _path.join)(this.#browserPath, EXTRACTED_FOLDER, 'Orbita-Browser.app')} < ${(0, _path.join)(this.#browserPath, MAC_HASH_FILE)} || echo ${FAIL_SUM_MATCH_MESSAGE}`);
+      const checkedRes = (calculatedHash || '').toString().trim();
+      if (checkedRes.includes(FAIL_SUM_MATCH_MESSAGE)) {
+        throw new Error('Error in sum matching. Please run script again.');
+      }
+      return;
+    }
+    const hashFileContent = await exec(`cat ${(0, _path.join)(this.#browserPath, DEB_HASH_FILE)}`);
+    let serverRes = (hashFileContent.stdout || '').toString().trim();
+    serverRes = serverRes.split(' ')[0];
+    const calculateLocalBrowserHash = await exec(`cd ${(0, _path.join)(this.#browserPath, EXTRACTED_FOLDER)} && find orbita-browser -type f -print0 | sort -z | \
+            xargs -0 sha256sum > ${this.#browserPath}/calculatedFolderSha.txt`);
+    const localHashContent = await exec(`cd ${this.#browserPath} && sha256sum calculatedFolderSha.txt`);
+    let userRes = (localHashContent.stdout || '').toString().trim();
+    userRes = userRes.split(' ')[0];
+    if (userRes !== serverRes) {
+      throw new Error('Error in sum matching. Please run script again.');
+    }
+  }
+  async replaceBrowser() {
+    console.log('Copy Orbita to target path');
+    if (PLATFORM === 'darwin') {
+      return rename((0, _path.join)(this.#browserPath, EXTRACTED_FOLDER), (0, _path.join)(this.#browserPath, 'orbita-browser'));
+    }
+    const targetBrowserPath = (0, _path.join)(this.#browserPath, 'orbita-browser');
+    await this.deleteDir(targetBrowserPath);
+    await this.copyDir((0, _path.join)(this.#browserPath, EXTRACTED_FOLDER, 'orbita-browser'), targetBrowserPath);
+  }
+  async deleteOldArchives(deleteCurrentBrowser = false) {
+    if (deleteCurrentBrowser) {
+      return this.deleteDir((0, _path.join)(this.#browserPath, 'orbita-browser'));
+    }
+    await this.deleteDir((0, _path.join)(this.#browserPath, EXTRACTED_FOLDER));
+    return readdir(this.#browserPath).then(files => {
+      const promises = [];
+      files.forEach(filename => {
+        if (filename.match(/(txt|dylib|mtree)/)) {
+          promises.push(unlink((0, _path.join)(this.#browserPath, filename)));
+        }
+      });
+      return Promise.all(promises);
+    }).catch(e => {
+      console.log(`Error in deleting old archives. ${e.message}`);
+      return Promise.resolve();
+    });
+  }
+  async copyDir(src, dest) {
+    await mkdir(dest);
+    const files = await readdir(src);
+    for (let i = 0; i < files.length; i++) {
+      const current = await lstat((0, _path.join)(src, files[i]));
+      if (current.isDirectory()) {
+        await this.copyDir((0, _path.join)(src, files[i]), (0, _path.join)(dest, files[i]));
+      } else if (current.isSymbolicLink()) {
+        const symlinkObj = await readlink((0, _path.join)(src, files[i]));
+        await symlink(symlinkObj, (0, _path.join)(dest, files[i]));
+      } else {
+        await copyFile((0, _path.join)(src, files[i]), (0, _path.join)(dest, files[i]));
+      }
+    }
+  }
+  getCurrentVersion() {
+    let command = `if [ -f ${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version')} ]; then cat ${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version')}; else echo 0.0.0; fi`;
+    if (PLATFORM === 'win32') {
+      command = `if exist "${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version')}" (type "${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version')}") else (echo 0.0.0)`;
+    } else if (PLATFORM === 'darwin') {
+      command = `if [ -f ${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version', VERSION_FILE)} ]; then cat ${(0, _path.join)(this.#browserPath, 'orbita-browser', 'version', VERSION_FILE)}; else echo 0.0.0; fi`;
+    }
+    return exec(command);
+  }
+  getLatestBrowserVersion() {
+    const userOs = (0, _common.getOS)();
+    return new Promise(resolve => (0, _https.get)(`${_common.API_URL}/gologin-global-settings/latest-browser-info?os=${userOs}`, {
+      timeout: 15 * 1000,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'gologin-api'
+      }
+    }, res => {
+      res.setEncoding('utf8');
+      let resultResponse = '';
+      res.on('data', data => resultResponse += data);
+      res.on('end', () => {
+        resolve(JSON.parse(resultResponse.trim()));
+      });
+    }).on('error', err => resolve('')));
+  }
+  get getOrbitaPath() {
+    return this.#executableFilePath;
+  }
+  async deleteDir(path = '') {
+    if (!path) {
+      return;
+    }
+    const directoryExists = await access(path).then(() => true).catch(() => false);
+    if (!directoryExists) {
+      return;
+    }
+    return rmdir(path, {
+      recursive: true
+    });
+  }
+}
+exports.BrowserChecker = BrowserChecker;
+var _default = exports.default = BrowserChecker;

package/dist/src/browser/browser-user-data-manager.js

@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uploadCookies = exports.setOriginalExtPaths = exports.setExtPathsAndRemoveDeleted = exports.recalculateId = exports.downloadFonts = exports.downloadCookies = exports.copyFontsConfigFile = exports.composeFonts = void 0;
+var _crypto = require("crypto");
+var _fs = require("fs");
+var _os = require("os");
+var _path = require("path");
+var _url = require("url");
+var _requestretry = _interopRequireDefault(require("requestretry"));
+var _fonts = require("../../fonts.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  access,
+  readFile,
+  writeFile,
+  mkdir,
+  readdir,
+  copyFile,
+  rename
+} = _fs.promises;
+const _filename = (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
+const _dirname = (0, _path.dirname)(_filename);
+const FONTS_URL = 'https://fonts.gologin.com/';
+const FONTS_DIR_NAME = 'fonts';
+const HOMEDIR = (0, _os.homedir)();
+const BROWSER_PATH = (0, _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;
+const downloadCookies = ({
+  profileId,
+  ACCESS_TOKEN,
+  API_BASE_URL
+}) => _requestretry.default.get(`${API_BASE_URL}/browser/${profileId}/cookies`, {
+  headers: {
+    Authorization: `Bearer ${ACCESS_TOKEN}`,
+    'user-agent': 'gologin-api'
+  },
+  json: true,
+  maxAttempts: 3,
+  retryDelay: 2000,
+  timeout: 10 * 1000
+}).catch(e => {
+  console.log(e);
+  return {
+    body: []
+  };
+});
+exports.downloadCookies = downloadCookies;
+const uploadCookies = ({
+  cookies = [],
+  profileId,
+  ACCESS_TOKEN,
+  API_BASE_URL
+}) => _requestretry.default.post(`${API_BASE_URL}/browser/${profileId}/cookies/?encrypted=true`, {
+  headers: {
+    Authorization: `Bearer ${ACCESS_TOKEN}`,
+    'User-Agent': 'gologin-api'
+  },
+  json: cookies,
+  maxAttempts: 3,
+  retryDelay: 2000,
+  timeout: 20 * 1000
+}).catch(e => {
+  console.log(e);
+  return e;
+});
+exports.uploadCookies = uploadCookies;
+const downloadFonts = async (fontsList = [], profilePath) => {
+  if (!fontsList.length) {
+    return;
+  }
+  const browserFontsPath = (0, _path.join)(BROWSER_PATH, FONTS_DIR_NAME);
+  await mkdir(browserFontsPath, {
+    recursive: true
+  });
+  const files = await readdir(browserFontsPath);
+  const fontsToDownload = fontsList.filter(font => !files.includes(font));
+  let promises = fontsToDownload.map(font => _requestretry.default.get(FONTS_URL + font, {
+    maxAttempts: 5,
+    retryDelay: 2000,
+    timeout: 30 * 1000
+  }).pipe((0, _fs.createWriteStream)((0, _path.join)(browserFontsPath, font))));
+  if (promises.length) {
+    await Promise.all(promises);
+  }
+  promises = fontsList.map(font => copyFile((0, _path.join)(browserFontsPath, font), (0, _path.join)(profilePath, FONTS_DIR_NAME, font)));
+  await Promise.all(promises);
+};
+exports.downloadFonts = downloadFonts;
+const composeFonts = async (fontsList = [], profilePath, differentOs = false) => {
+  if (!(fontsList.length && profilePath)) {
+    return;
+  }
+  const fontsToDownload = _fonts.fontsCollection.filter(elem => fontsList.includes(elem.value)).reduce((res, elem) => res.concat(elem.fileNames || []), []);
+  if (differentOs && !fontsToDownload.length) {
+    throw new Error('No fonts to download found. Use getAvailableFonts() method and set some fonts from this list');
+  }
+  fontsToDownload.push('LICENSE.txt');
+  fontsToDownload.push('OFL.txt');
+  const pathToFontsDir = (0, _path.join)(profilePath, FONTS_DIR_NAME);
+  const fontsDirExists = await access(pathToFontsDir).then(() => true, () => false);
+  if (fontsDirExists) {
+    (0, _fs.rmdirSync)(pathToFontsDir, {
+      recursive: true
+    });
+  }
+  await mkdir(pathToFontsDir, {
+    recursive: true
+  });
+  await downloadFonts(fontsToDownload, profilePath);
+  if (OS_PLATFORM === 'linux') {
+    await copyFontsConfigFile(profilePath);
+  }
+};
+exports.composeFonts = composeFonts;
+const copyFontsConfigFile = async profilePath => {
+  if (!profilePath) {
+    return;
+  }
+  const fileContent = await readFile((0, _path.resolve)(_dirname, '..', '..', 'fonts_config'), 'utf-8');
+  const result = fileContent.replace(/\$\$GOLOGIN_FONTS\$\$/g, (0, _path.join)(profilePath, FONTS_DIR_NAME));
+  const defaultFolderPath = (0, _path.join)(profilePath, 'Default');
+  await mkdir(defaultFolderPath, {
+    recursive: true
+  });
+  await writeFile((0, _path.join)(defaultFolderPath, 'fonts_config'), result);
+};
+exports.copyFontsConfigFile = copyFontsConfigFile;
+const setExtPathsAndRemoveDeleted = (settings = {}, profileExtensionsCheckRes = [], profileId = '') => {
+  const formattedLocalExtArray = profileExtensionsCheckRes.map(el => {
+    const [extFolderName = ''] = el.split(_path.sep).reverse();
+    const [originalId] = extFolderName.split('@');
+    if (!originalId) {
+      return null;
+    }
+    return {
+      path: el,
+      originalId
+    };
+  }).filter(Boolean);
+  const extensionsSettings = settings.extensions?.settings || {};
+  const extensionsEntries = Object.entries(extensionsSettings);
+  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)) && [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 (osPlatform === 'win32') {
+      extPath = extPath.replace(/\//g, '\\');
+    } else {
+      extPath = extPath.replace(/\\/g, '/');
+    }
+    extensionsSettings[extensionId].path = extPath;
+    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;
+      }
+    }
+    const localExtObj = originalId && formattedLocalExtArray.find(el => el.path.includes(originalId));
+    if (!localExtObj) {
+      return;
+    }
+    const initialExtName = extensionId;
+    extensionId = await recalculateId({
+      localExtObj,
+      extensionId,
+      extensionsSettings,
+      currentExtSettings
+    });
+    if (initialExtName !== extensionId) {
+      const profilePath = (0, _path.join)((0, _os.tmpdir)(), `gologin_profile_${profileId}`);
+      const extSyncFolder = (0, _path.join)(profilePath, 'Default', 'Sync Extension Settings', initialExtName);
+      const newSyncFolder = (0, _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 Promise.all(promises).then(() => extensionsSettings);
+};
+exports.setExtPathsAndRemoveDeleted = setExtPathsAndRemoveDeleted;
+const setOriginalExtPaths = async (settings = {}, originalExtensionsFolder = '') => {
+  if (!originalExtensionsFolder) {
+    return null;
+  }
+  const extensionsSettings = settings.extensions?.settings || {};
+  const extensionsEntries = Object.entries(extensionsSettings);
+  const originalExtensionsList = await readdir(originalExtensionsFolder).catch(() => []);
+  if (!originalExtensionsList.length) {
+    return null;
+  }
+  const promises = originalExtensionsList.map(async originalId => {
+    const extFolderPath = (0, _path.join)(originalExtensionsFolder, originalId);
+    const extFolderContent = await readdir(extFolderPath);
+    if (!extFolderPath.length) {
+      return {};
+    }
+    if (extFolderContent.includes('manifest.json')) {
+      return {
+        originalId,
+        path: (0, _path.join)(originalExtensionsFolder, originalId)
+      };
+    }
+    const [version] = extFolderContent;
+    return {
+      originalId,
+      path: (0, _path.join)(originalExtensionsFolder, originalId, version)
+    };
+  });
+  const originalExtPaths = await Promise.all(promises);
+  extensionsEntries.forEach(extensionObj => {
+    const [extensionsId] = extensionObj;
+    const extPath = extensionsSettings[extensionsId].path;
+    if (!/chrome-extensions/.test(extPath)) {
+      return;
+    }
+    const originalExtPath = originalExtPaths.find(el => el.originalId === extensionsId);
+    if (!originalExtPath) {
+      return;
+    }
+    extensionsSettings[extensionsId].path = originalExtPath.path || '';
+  });
+  return extensionsSettings;
+};
+exports.setOriginalExtPaths = setOriginalExtPaths;
+const recalculateId = async ({
+  localExtObj,
+  extensionId,
+  extensionsSettings,
+  currentExtSettings
+}) => {
+  if (currentExtSettings.manifest?.key) {
+    return extensionId;
+  }
+  const manifestFilePath = (0, _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 = (0, _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;
+};
+exports.recalculateId = recalculateId;
+const extIdEncoding = {
+  0: 'a',
+  1: 'b',
+  2: 'c',
+  3: 'd',
+  4: 'e',
+  5: 'f',
+  6: 'g',
+  7: 'h',
+  8: 'i',
+  9: 'j',
+  a: 'k',
+  b: 'l',
+  c: 'm',
+  d: 'n',
+  e: 'o',
+  f: 'p'
+};