gologin 2.1.12 → 2.1.14

package/gologin/src/extensions/extensions-manager.js

@@ -1,384 +0,0 @@
-import { createWriteStream, promises as _promises } from 'fs';
-import { join, sep } from 'path';
-import request from 'requestretry';
-
-import { CHROME_EXTENSIONS_PATH, composeExtractionPromises, USER_EXTENSIONS_PATH } from '../utils/common.js';
-import UserExtensionsManager from './user-extensions-manager.js';
-
-const { mkdir, readdir, rmdir, unlink } = _promises;
-
-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';
-
-export class ExtensionsManager extends UserExtensionsManager {
-  #existedChromeExtensions = [];
-  #inited = false;
-  #useLocalExtStorage = false;
-  #useCookiesExt = false;
-  #deleteProfileExtFolders = false;
-  #extensionsUpdating = true;
-
-  constructor() {
-    super();
-    if (!ExtensionsManager.instance) {
-      ExtensionsManager.instance = this;
-    }
-
-    return ExtensionsManager.instance;
-  }
-
-  async init() {
-    if (this.#inited) {
-      return Promise.resolve();
-    }
-
-    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(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(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;
-  }
-
-  async checkChromeExtensions(profileExtensions = []) {
-    if (!(Array.isArray(profileExtensions) && profileExtensions.length)) {
-      return [];
-    }
-
-    const extensionsToDownload = this.#getExtensionsToDownload(profileExtensions);
-
-    const downloadedArchives = await this.downloadChromeExtensions(extensionsToDownload);
-    const filteredArchives = downloadedArchives.filter(Boolean);
-
-    if (filteredArchives.length) {
-      const [downloadedFolders] = filteredArchives.map(archivePath => archivePath.split(sep).reverse());
-      this.#existedChromeExtensions = [...this.#existedChromeExtensions, ...downloadedFolders];
-
-      const promises = composeExtractionPromises(filteredArchives);
-
-      await Promise.all(promises);
-    }
-
-    return this.getExtensionsStrToIncludeAsOrbitaParam(profileExtensions);
-  }
-
-  #getExtensionsToDownload(profileExtensions) {
-    const existedExtensionsFolders = [...this.#existedChromeExtensions, ...this.existedUserExtensions];
-    const existedOriginalIds = existedExtensionsFolders.map((val) => {
-      const [originalId] = val.split('@');
-
-      return originalId;
-    });
-
-    return profileExtensions.reduce((res, val) => {
-      const [originalId] = val.split('@');
-      const extensionExists = existedOriginalIds.includes(originalId);
-      if (!extensionExists) {
-        res.push(val);
-      }
-
-      return res;
-    }, []);
-  }
-
-  async downloadChromeExtensions(idsToDownload = []) {
-    if (!(Array.isArray(idsToDownload) && idsToDownload.length)) {
-      return [];
-    }
-
-    const promises = idsToDownload.map(async (id) => {
-      const [originalId] = id.split('@');
-      const extUrl = EXTENSION_URL.replace('{ext_id}', originalId);
-
-      const uploadedProfileMetadata = await getExtMetadata(extUrl);
-
-      const reqPath = uploadedProfileMetadata.req.path;
-      const extVer = getExtVersion(reqPath);
-
-      const buffer = await new Promise((res) => {
-        const chunks = [];
-        request.get(extUrl, {
-          maxAttempts: 3,
-          retryDelay: 1000,
-          timeout: 8 * 1000,
-          fullResponse: false,
-        })
-          .on('data', (data) => chunks.push(data))
-          .on('end', () => res(Buffer.concat(chunks)));
-      });
-
-      let zipExt;
-      try {
-        zipExt = crxToZip(buffer);
-      } catch (e) {
-        console.log(e);
-
-        return '';
-      }
-
-      const archiveZipPath = join(CHROME_EXTENSIONS_PATH, originalId + '@' + extVer + '.zip');
-
-      const archiveZip = createWriteStream(archiveZipPath);
-      archiveZip.write(zipExt);
-      archiveZip.close();
-
-      return new Promise(r => archiveZip.on('close', () => r(archiveZipPath)));
-    });
-
-    return Promise.all(promises);
-  }
-
-  async getExtensionsPolicies() {
-    const globalExtConfig = await request.get(`${this.apiBaseUrl}/gologin-settings/chrome_ext_policies`, {
-      headers: {
-        Authorization: `Bearer ${this.accessToken}`,
-        'user-agent': this.userAgent,
-        'x-two-factor-token': this.twoFaKey || '',
-      },
-      json: true,
-      maxAttempts: 2,
-      retryDelay: 1000,
-      timeout: 10 * 1000,
-      fullResponse: false,
-    });
-
-    const chromeExtPolicies = globalExtConfig?.chromeExtPolicies || {};
-    const {
-      useLocalExtStorage = false,
-      deleteProfileExtFolders = false,
-      useCookiesExt = true,
-    } = chromeExtPolicies;
-
-    this.#useLocalExtStorage = useLocalExtStorage;
-    this.#deleteProfileExtFolders = deleteProfileExtFolders;
-    this.#useCookiesExt = useCookiesExt;
-  }
-
-  async updateExtensions() {
-    const fileList = await readdir(CHROME_EXTENSIONS_PATH).catch(() => []);
-    if (!fileList.length) {
-      return;
-    }
-
-    const oldFolders = [];
-
-    const versionCheckPromises = fileList.map(async (extension) => {
-      if (!extension.includes('@') || extension.includes('.zip')) {
-        return '';
-      }
-
-      const [originalId, currentVersion] = extension.split('@');
-      const extUrl = EXTENSION_URL.replace('{ext_id}', originalId);
-      const uploadedProfileMetadata = await getExtMetadata(extUrl);
-      const reqPath = uploadedProfileMetadata.req.path;
-      const availableVersion = getExtVersion(reqPath);
-
-      if (currentVersion === availableVersion) {
-        return '';
-      }
-
-      oldFolders.push(join(CHROME_EXTENSIONS_PATH, extension));
-
-      return originalId;
-    });
-
-    const extensionsNames = (await Promise.all(versionCheckPromises)).filter(Boolean);
-    const archivesPaths = (await this.downloadChromeExtensions(extensionsNames)).filter(Boolean);
-    const extractionPromises = composeExtractionPromises(archivesPaths);
-    await Promise.all(extractionPromises);
-
-    const removeFoldersPromises = oldFolders.map(folder => (
-      rmdir(folder, { recursive: true, maxRetries: 3 }).catch(() => {})
-    ));
-
-    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) {
-    if (!extensionsFromPref) {
-      return [];
-    }
-
-    const objectEntries = Object.entries(extensionsFromPref);
-    const extensionsInPref = objectEntries?.map(([_, settings]) => {
-      const [extFolderName] = settings.path.split(sep).reverse();
-      const [originalId] = extFolderName.split('@');
-
-      return originalId;
-    }) || [];
-
-    return extensionsFromDB.reduce((acc, extension) => {
-      const [extFolderName] = extension.split(sep).reverse();
-      const [originalId] = extFolderName.split('@');
-      if (!extensionsInPref.includes(originalId)) {
-        acc.push(extension);
-      }
-
-      return acc;
-    }, []);
-  }
-}
-
-const crxToZip = (buf) => {
-  if (buf[0] === 80 && buf[1] === 75 && buf[2] === 3 && buf[3] === 4) {
-    return buf;
-  }
-
-  if (!(buf[0] === 67 || buf[1] === 114 || buf[2] === 50 || buf[3] === 52)) {
-    throw new Error('Invalid header: Does not start with Cr24');
-  }
-
-  const isV3 = buf[4] === 3;
-  const isV2 = buf[4] === 2;
-
-  if (!(isV2 || isV3) || buf[5] || buf[6] || buf[7]) {
-    throw new Error('Unexpected crx format version number.');
-  }
-
-  if (isV2) {
-    const publicKeyLength = calcLength(buf[8], buf[9], buf[10], buf[11]);
-    const signatureLength = calcLength(buf[12], buf[13], buf[14], buf[15]);
-
-    const zipStartOffset = 16 + publicKeyLength + signatureLength;
-
-    return buf.slice(zipStartOffset, buf.length);
-  }
-
-  const headerSize = calcLength(buf[8], buf[9], buf[10], buf[11]);
-  const zipStartOffset = 12 + headerSize;
-
-  return buf.slice(zipStartOffset, buf.length);
-};
-
-const calcLength = (a, b, c, d) => {
-  let length = 0;
-
-  length += a << 0;
-  length += b << 8;
-  length += c << 16;
-  length += d << 24 >>> 0;
-
-  return length;
-};
-
-const getExtMetadata = (extUrl) => (
-  request.head(extUrl, {
-    maxAttempts: 3,
-    retryDelay: 2000,
-    timeout: 2 * 1000,
-    fullResponse: true,
-  })
-);
-
-const getExtVersion = (metadata) => {
-  const [extFullName = ''] = metadata.split('/').reverse();
-  const [extName = ''] = extFullName.split('.');
-  const splitExtName = extName.split('_');
-  splitExtName.shift();
-
-  return splitExtName.join('_');
-};
-
-export default ExtensionsManager;
-

package/gologin/src/extensions/user-extensions-manager.js

@@ -1,295 +0,0 @@
-import { createWriteStream, promises as _promises } from 'fs';
-import { join, sep } from 'path';
-import request from 'requestretry';
-
-import { CHROME_EXTENSIONS_PATH, composeExtractionPromises, USER_EXTENSIONS_PATH } from '../utils/common.js';
-
-const { readdir, readFile, stat, mkdir, copyFile } = _promises;
-
-export 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;
-  }
-
-  checkLocalUserChromeExtensions = async (userChromeExtensions, profileId) => {
-    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,
-        profileId,
-        userChromeExtensions,
-      },
-    }) || [];
-
-    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 = `${join(USER_EXTENSIONS_PATH, extId)}.zip`;
-      const archiveZip = 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(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 => join(folderPath, folderName)));
-
-    if (!folders.length) {
-      return [];
-    }
-
-    const formattedIdsList = folders.map((el) => {
-      const [folderName] = el.split(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(join(pathToExtensions, folderName));
-        pathToExtensionsFolder = [pathToExtensions, folderName, extensionVersion];
-      }
-
-      const manifestPath = 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 = 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) {
-          console.log(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 = 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(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(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(join(fromPath, file), join(destPath, file));
-  });
-
-  return Promise.all(promises);
-};
-
-export default UserExtensionsManager;