gologin 2.1.12 → 2.1.13

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

@@ -1,335 +0,0 @@
-import { createHash } from 'crypto';
-import { createWriteStream, promises as _promises, rmdirSync } from 'fs';
-import { homedir, tmpdir } from 'os';
-import { dirname, join, resolve, sep } from 'path';
-import requestretry from 'requestretry';
-import { fileURLToPath } from 'url';
-
-import { fontsCollection } from '../../fonts.js';
-
-const { access, readFile, writeFile, mkdir, readdir, copyFile, rename } = _promises;
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const FONTS_URL = 'https://fonts.gologin.com/';
-const FONTS_DIR_NAME = 'fonts';
-
-const HOMEDIR = homedir();
-const BROWSER_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;
-
-export const downloadCookies = ({ profileId, ACCESS_TOKEN, API_BASE_URL }) =>
-  requestretry.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: [] };
-  });
-
-export const uploadCookies = ({ cookies = [], profileId, ACCESS_TOKEN, API_BASE_URL }) =>
-  requestretry.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;
-  });
-
-export const downloadFonts = async (fontsList = [], profilePath) => {
-  if (!fontsList.length) {
-    return;
-  }
-
-  const browserFontsPath = 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.get(FONTS_URL + font, {
-    maxAttempts: 5,
-    retryDelay: 2000,
-    timeout: 30 * 1000,
-  })
-    .pipe(createWriteStream(join(browserFontsPath, font))),
-  );
-
-  if (promises.length) {
-    await Promise.all(promises);
-  }
-
-  promises = fontsList.map((font) =>
-    copyFile(join(browserFontsPath, font), join(profilePath, FONTS_DIR_NAME, font)));
-
-  await Promise.all(promises);
-};
-
-export const composeFonts = async (fontsList = [], profilePath, differentOs = false) => {
-  if (!(fontsList.length && profilePath)) {
-    return;
-  }
-
-  const fontsToDownload = 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 = join(profilePath, FONTS_DIR_NAME);
-  const fontsDirExists = await access(pathToFontsDir).then(() => true, () => false);
-  if (fontsDirExists) {
-    rmdirSync(pathToFontsDir, { recursive: true });
-  }
-
-  await mkdir(pathToFontsDir, { recursive: true });
-  await downloadFonts(fontsToDownload, profilePath);
-
-  if (OS_PLATFORM === 'linux') {
-    await copyFontsConfigFile(profilePath);
-  }
-};
-
-export const copyFontsConfigFile = async (profilePath) => {
-  if (!profilePath) {
-    return;
-  }
-
-  const fileContent = await readFile(resolve(__dirname, '..', '..', 'fonts_config'), 'utf-8');
-  const result = fileContent.replace(/\$\$GOLOGIN_FONTS\$\$/g, join(profilePath, FONTS_DIR_NAME));
-
-  const defaultFolderPath = join(profilePath, 'Default');
-  await mkdir(defaultFolderPath, { recursive: true });
-  await writeFile(join(defaultFolderPath, 'fonts_config'), result);
-};
-
-export const setExtPathsAndRemoveDeleted = (settings = {}, profileExtensionsCheckRes = [], profileId = '') => {
-  const formattedLocalExtArray = profileExtensionsCheckRes.map((el) => {
-    const [extFolderName = ''] = el.split(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(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(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 = join(tmpdir(), `gologin_profile_${profileId}`);
-      const extSyncFolder = join(profilePath, 'Default', 'Sync Extension Settings', initialExtName);
-      const newSyncFolder = 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);
-};
-
-export 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 = join(originalExtensionsFolder, originalId);
-    const extFolderContent = await readdir(extFolderPath);
-    if (!extFolderPath.length) {
-      return {};
-    }
-
-    if (extFolderContent.includes('manifest.json')) {
-      return {
-        originalId,
-        path: join(originalExtensionsFolder, originalId),
-      };
-    }
-
-    const [version] = extFolderContent;
-
-    return {
-      originalId,
-      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;
-};
-
-export const recalculateId = async ({ localExtObj, extensionId, extensionsSettings, currentExtSettings }) => {
-  if (currentExtSettings.manifest?.key) {
-    return extensionId;
-  }
-
-  const manifestFilePath = 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 = 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 = {
-  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',
-};

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

@@ -1,189 +0,0 @@
-import { open } from 'sqlite';
-import sqlite3 from 'sqlite3';
-import { promises as fsPromises } from 'fs';
-import { join } from 'path';
-
-const { access } = fsPromises;
-const { Database, OPEN_READONLY } = sqlite3;
-
-const MAX_SQLITE_VARIABLES = 76;
-
-const SAME_SITE = {
-  '-1': 'unspecified',
-  0: 'no_restriction',
-  1: 'lax',
-  2: 'strict',
-};
-
-export const getDB = (filePath, readOnly = true) => {
-  const connectionOpts = {
-    filename: filePath,
-    driver: Database,
-  };
-
-  if (readOnly) {
-    connectionOpts.mode = OPEN_READONLY;
-  }
-
-  return open(connectionOpts);
-}
-
-export const getChunckedInsertValues = (cookiesArr) => {
-  const todayUnix = Math.floor(new Date().getTime() / 1000.0);
-  const chunckedCookiesArr = chunk(cookiesArr, MAX_SQLITE_VARIABLES);
-
-  return chunckedCookiesArr.map((cookies) => {
-    const queryPlaceholders = cookies.map(() => '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').join(', ');
-    const query = `insert or replace into cookies (creation_utc, host_key, top_frame_site_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, last_access_utc, has_expires, is_persistent, priority, samesite, source_scheme, source_port, is_same_party, last_update_utc) values ${queryPlaceholders}`;
-    const queryParams = cookies.flatMap((cookie) => {
-      const creationDate = cookie.creationDate ? cookie.creationDate : unixToLDAP(todayUnix);
-      let expirationDate = cookie.session ? 0 : unixToLDAP(cookie.expirationDate);
-      const encryptedValue = cookie.value;
-      const samesite = Object.keys(SAME_SITE).find((key) => SAME_SITE[key] === (cookie.sameSite || '-1'));
-      const isSecure =
-        cookie.name.startsWith('__Host-') || cookie.name.startsWith('__Secure-') ? 1 : Number(cookie.secure);
-
-      const sourceScheme = isSecure === 1 ? 2 : 1;
-      const sourcePort = isSecure === 1 ? 443 : 80;
-      // eslint-disable-next-line no-undefined
-      let isPersistent = [undefined, null].includes(cookie.session)
-        ? Number(expirationDate !== 0)
-        : Number(!cookie.session);
-
-      if (/^(\.)?mail.google.com$/.test(cookie.domain) && cookie.name === 'COMPASS') {
-        expirationDate = 0;
-        isPersistent = 0;
-      }
-
-      return [
-        creationDate,
-        cookie.domain,
-        '', // top_frame_site_key
-        cookie.name,
-        '', // value
-        encryptedValue,
-        cookie.path,
-        expirationDate,
-        isSecure,
-        Number(cookie.httpOnly),
-        0, // last_access_utc
-        expirationDate === 0 ? 0 : 1, // has_expires
-        isPersistent,
-        1, // default priority value (https://github.com/chromium/chromium/blob/main/net/cookies/cookie_constants.h)
-        samesite,
-        sourceScheme,
-        sourcePort,
-        0, // is_same_party
-        0, // last_update_utc
-      ];
-    });
-
-    return [query, queryParams];
-  });
-}
-
-export const loadCookiesFromFile = async (filePath) => {
-  let db;
-  const cookies = [];
-
-  try {
-    db = await getDB(filePath);
-    const cookiesRows = await db.all('select * from cookies');
-    for (const row of cookiesRows) {
-      const {
-        host_key,
-        name,
-        encrypted_value,
-        path,
-        is_secure,
-        is_httponly,
-        expires_utc,
-        is_persistent,
-        samesite,
-        creation_utc,
-      } = row;
-
-      cookies.push({
-        url: buildCookieURL(host_key, is_secure, path),
-        domain: host_key,
-        name,
-        value: encrypted_value,
-        path,
-        sameSite: SAME_SITE[samesite],
-        secure: Boolean(is_secure),
-        httpOnly: Boolean(is_httponly),
-        hostOnly: !host_key.startsWith('.'),
-        session: !is_persistent,
-        expirationDate: ldapToUnix(expires_utc),
-        creationDate: ldapToUnix(creation_utc),
-      });
-    }
-  } catch (error) {
-    console.log(error);
-  } finally {
-    db && await db.close();
-  }
-
-  return cookies;
-}
-
-export const unixToLDAP = (unixtime) => {
-  if (unixtime === 0) {
-    return unixtime;
-  }
-
-  const win32filetime = new Date(Date.UTC(1601, 0, 1)).getTime() / 1000;
-  const sum = unixtime - win32filetime;
-
-  return sum * 1000000;
-}
-
-export const ldapToUnix = (ldap) => {
-  const ldapLength = ldap.toString().length;
-  if (ldap === 0 || ldapLength > 18) {
-    return ldap;
-  }
-
-  let _ldap = ldap;
-  if (ldapLength < 18) {
-    _ldap = Number(_ldap + '0'.repeat(18 - ldapLength));
-  }
-
-  const win32filetime = new Date(Date.UTC(1601, 0, 1)).getTime();
-
-  return (_ldap / 10000 + win32filetime) / 1000;
-}
-
-export const buildCookieURL = (domain, secure, path) => {
-  let domainWithoutDot = domain;
-  if (domain.startsWith('.')) {
-    domainWithoutDot = domain.substr(1);
-  }
-
-  return 'http' + (secure ? 's' : '') + '://' + domainWithoutDot + path;
-}
-
-export const chunk = (arr, chunkSize = 1, cache = []) => {
-  const tmp = [...arr];
-  if (chunkSize <= 0) {
-    return cache;
-  }
-
-  while (tmp.length) {
-    cache.push(tmp.splice(0, chunkSize));
-  }
-
-  return cache;
-}
-
-export const getCookiesFilePath = async (profileId, tmpdir) => {
-  const baseCookiesFilePath = join(tmpdir, `gologin_profile_${profileId}`, 'Default', 'Cookies');
-  const bypassCookiesFilePath = join(tmpdir, `gologin_profile_${profileId}`, 'Default', 'Network', 'Cookies');
-
-  return access(baseCookiesFilePath)
-    .then(() => baseCookiesFilePath)
-    .catch(() => access(bypassCookiesFilePath)
-      .then(() => bypassCookiesFilePath)
-      .catch(() => baseCookiesFilePath)
-    );
-}

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

@@ -1,56 +0,0 @@
-import decompress from 'decompress';
-import decompressUnzip from 'decompress-unzip';
-import { promises } from 'fs';
-
-const { access, unlink } = promises;
-
-export const extractExtension = (source, dest) => {
-  if (!(source && dest)) {
-    throw new Error('Missing parameter');
-  }
-
-  return access(source)
-    .then(() =>
-      withRetry({
-        fn() {
-          return decompress(source, dest, {
-            plugins: [decompressUnzip()],
-            filter: file => !file.path.endsWith('/'),
-          });
-        },
-      }),
-    );
-}
-
-export const deleteExtensionArchive = (dest) => {
-  if (!dest) {
-    throw new Error('Missing parameter');
-  }
-
-  return access(dest)
-    .then(
-      () => unlink(dest),
-      () => Promise.resolve(),
-    );
-}
-
-const withRetry = optionsOrUndefined => {
-  const opts = optionsOrUndefined || {};
-  const callCounter = opts.callCounter || 1;
-  const fnToProducePromise = opts.fn;
-  const callLimit = opts.limit || 5;
-  delete opts.callCounter;
-
-  return fnToProducePromise(opts).catch(err => {
-    console.error(err);
-    if (callCounter >= callLimit) {
-      return Promise.reject(err);
-    }
-
-    opts.callCounter = callCounter + 1;
-
-    return new Promise(resolve => process.nextTick(resolve)).then(() =>
-      withRetry(opts),
-    );
-  });
-};