gologin 2.1.15 → 2.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin",
-  "version": "2.1.15",
+  "version": "2.1.17",
   "description": "A high-level API to control Orbita browser over GoLogin API",
   "types": "./index.d.ts",
   "main": "./src/gologin.js",

package/src/browser/browser-checker.js

@@ -6,10 +6,8 @@ import { get } from 'https';
 import { homedir } from 'os';
 import { join } from 'path';
 import ProgressBar from 'progress';
-import { createInterface } from 'readline';
 import util from 'util';
 
-import { findLatestBrowserVersionDirectory } from '../utils/utils.js';
 import { API_URL, getOS } from '../utils/common.js';
 
 const exec = util.promisify(execNonPromise);
@@ -37,87 +35,65 @@ const FAIL_SUM_MATCH_MESSAGE = 'hash_sum_not_matched';
 const EXTRACTED_FOLDER = 'extracted-browser';
 
 export class BrowserChecker {
-  #homedir;
-  #browserPath;
+  #homedir = homedir();
+  #browserPath = join(this.#homedir, '.gologin', 'browser');
   #executableFilePath;
   #skipOrbitaHashChecking = false;
 
-  constructor(skipOrbitaHashChecking) {
-    this.#skipOrbitaHashChecking = skipOrbitaHashChecking;
-    this.#homedir = homedir();
-    this.#browserPath = join(this.#homedir, '.gologin', 'browser');
+  constructor() {
 
-    let executableFilePath = join(this.#browserPath, 'orbita-browser', 'chrome');
-    if (PLATFORM === 'darwin') {
-      const orbitaFolderName = findLatestBrowserVersionDirectory(this.#browserPath);
-      if (orbitaFolderName === 'error') {
-        throw Error('Orbita folder not found in this directory: ' + this.#browserPath);
-      }
-
-      executableFilePath = join(this.#browserPath, orbitaFolderName, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
-    } else if (PLATFORM === 'win32') {
-      executableFilePath = 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;
+  async checkBrowser(majorVersion) {
+    const isBrowserFolderExists = await access(join(this.#browserPath, `orbita-browser-${majorVersion}`)).then(() => true).catch(() => false);
+    if (isBrowserFolderExists) {
+      return this.getBrowserExecutablePath(majorVersion);
     }
 
-    if (autoUpdateBrowser) {
-      return this.downloadBrowser(browserLatestVersion, browserDownloadUrl);
-    }
+    await this.downloadBrowser(majorVersion);
 
-    return new Promise(resolve => {
-      const rl = 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();
-      });
-    });
+    return this.getBrowserExecutablePath(majorVersion);
   }
 
-  async downloadBrowser(latestVersion, browserDownloadUrl) {
-    await this.deleteOldArchives(true);
+  async downloadBrowser(majorVersion) {
     await mkdir(this.#browserPath, { recursive: true });
 
-    const pathStr = join(this.#browserPath, BROWSER_ARCHIVE_NAME);
+    const browserPath = join(this.#browserPath, BROWSER_ARCHIVE_NAME);
 
-    await this.downloadBrowserArchive(browserDownloadUrl, pathStr);
-    await this.checkBrowserArchive(pathStr);
+    const browserDownloadUrl = this.getBrowserDownloadUrl(majorVersion);
+
+    await this.downloadBrowserArchive(browserDownloadUrl, browserPath);
     await this.extractBrowser();
-    await this.checkBrowserSum(latestVersion);
-    console.log('Orbita hash checked successfully');
-    await this.replaceBrowser();
-    await this.addLatestVersion(latestVersion).catch(() => null);
+    await this.replaceBrowser(majorVersion);
     await this.deleteOldArchives();
-    console.log('Orbita updated successfully');
+  }
+
+  getBrowserExecutablePath(majorVersion) {
+    const os = getOS();
+    switch (os) {
+      case 'mac':
+        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
+      case 'win':
+        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'chrome.exe');
+      case 'macM1':
+        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
+      default:
+        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'chrome');
+    }
+  }
+
+  getBrowserDownloadUrl(majorVersion) {
+    const os = getOS();
+    switch (os) {
+      case 'mac':
+        return `https://orbita-browser-mac.gologin.com/orbita-browser-latest-${majorVersion}.tar.gz`;
+      case 'win':
+        return `https://orbita-browser-windows.gologin.com/orbita-browser-latest-${majorVersion}.zip`;
+      case 'macM1':
+        return `https://orbita-browser-mac-arm.gologin.com/orbita-browser-latest-${majorVersion}.tar.gz`;
+      default:
+        return `https://orbita-browser-linux.gologin.com/orbita-browser-latest-${majorVersion}.tar.gz`;
+    }
   }
 
   addLatestVersion(latestVersion) {
@@ -208,6 +184,7 @@ export class BrowserChecker {
       if (ARCH === 'arm64') {
         hashLink = MAC_ARM_HASHFILE_LINK;
       }
+
       resultPath = join(this.#browserPath, MAC_HASH_FILE);
     }
 
@@ -282,13 +259,13 @@ export class BrowserChecker {
     }
   }
 
-  async replaceBrowser() {
+  async replaceBrowser(majorVersion) {
     console.log('Copy Orbita to target path');
     if (PLATFORM === 'darwin') {
-      return rename(join(this.#browserPath, EXTRACTED_FOLDER), join(this.#browserPath, 'orbita-browser'))
+      return rename(join(this.#browserPath, EXTRACTED_FOLDER), join(this.#browserPath, `orbita-browser-${majorVersion}`));
     }
 
-    const targetBrowserPath = join(this.#browserPath, 'orbita-browser');
+    const targetBrowserPath = join(this.#browserPath, `orbita-browser-${majorVersion}`);
     await this.deleteDir(targetBrowserPath);
 
     await this.copyDir(

package/src/gologin.js

@@ -92,8 +92,8 @@ export class GoLogin {
     debug('INIT GOLOGIN', this.profile_id);
   }
 
-  async checkBrowser() {
-    return this.browserChecker.checkBrowser(this.autoUpdateBrowser, this.checkBrowserUpdate);
+  async checkBrowser(majorVersion) {
+    this.executablePath = await this.browserChecker.checkBrowser(majorVersion);
   }
 
   async setProfileId(profile_id) {
@@ -252,63 +252,105 @@ export class GoLogin {
     return profile;
   }
 
-  convertPreferences(preferences) {
-    if (get(preferences, 'navigator.userAgent')) {
-      preferences.userAgent = get(preferences, 'navigator.userAgent');
-    }
-
-    if (get(preferences, 'navigator.doNotTrack')) {
-      preferences.doNotTrack = get(preferences, 'navigator.doNotTrack');
-    }
-
-    if (get(preferences, 'navigator.hardwareConcurrency')) {
-      preferences.hardwareConcurrency = get(preferences, 'navigator.hardwareConcurrency');
-    }
-
-    if (get(preferences, 'navigator.deviceMemory')) {
-      preferences.deviceMemory = get(preferences, 'navigator.deviceMemory') * 1024;
-    }
-
-    if (get(preferences, 'navigator.language')) {
-      preferences.langHeader = get(preferences, 'navigator.language');
-      preferences.languages = get(preferences, 'navigator.language').replace(/;|q=[\d\.]+/img, '');
-    }
-
-    if (get(preferences, 'navigator.maxTouchPoints')) {
-      preferences.navigator.max_touch_points = get(preferences, 'navigator.maxTouchPoints');
-    }
-
-    if (get(preferences, 'isM1')) {
-      preferences.is_m1 = get(preferences, 'isM1');
-    }
-
-    if (get(preferences, 'os') == 'android') {
-      const devicePixelRatio = get(preferences, 'devicePixelRatio');
-      const deviceScaleFactorCeil = Math.ceil(devicePixelRatio || 3.5);
-      let deviceScaleFactor = devicePixelRatio;
-      if (deviceScaleFactorCeil === devicePixelRatio) {
-        deviceScaleFactor += 0.00000001;
-      }
-
-      preferences.mobile = {
-        enable: true,
-        width: parseInt(this.resolution.width, 10),
-        height: parseInt(this.resolution.height, 10),
-        device_scale_factor: deviceScaleFactor,
-      };
-    }
-
-    preferences.mediaDevices = {
-      enable: preferences.mediaDevices.enableMasking,
-      videoInputs: preferences.mediaDevices.videoInputs,
-      audioInputs: preferences.mediaDevices.audioInputs,
-      audioOutputs: preferences.mediaDevices.audioOutputs,
-    };
-
-    preferences.webRtc = {
-      ...preferences.webRtc,
-      fill_based_on_ip: !!get(preferences, 'webRTC.fillBasedOnIp'),
-      local_ip_masking: !!get(preferences, 'webRTC.local_ip_masking'),
+  getGologinPreferences(profileData) {
+    const os = profileData.os || '';
+    const osSpec = profileData.osSpec || '';
+    const isM1 = profileData.isM1 || false;
+    const isArm = (os === 'mac' && osSpec && osSpec.includes('M')) || isM1;
+    const resolution = (profileData.navigator && profileData.navigator.resolution) || '1920x1080';
+    const [screenWidth, screenHeight] = resolution.split('x').map(Number);
+    const langHeader = (profileData.navigator && profileData.navigator.language) || '';
+    console.log('langHeader', langHeader);
+    const splittedLangs = langHeader ? langHeader.split(',')[0] : 'en-US';
+
+    const startupUrl = (profileData.startUrl || '').trim().split(',')[0];
+    const startupUrls = (profileData.startUrl || '').split(',')
+      .map(url => url.trim())
+      .filter(url => url);
+
+    const preferences = {
+      profile_id: profileData.id,
+      name: profileData.name,
+      is_m1: isArm,
+      navigator: {
+        platform: (profileData.navigator?.platform) || '',
+        max_touch_points: (profileData.navigator?.maxTouchPoints) || 0,
+      },
+      dns: profileData.dns || {},
+      proxy: {
+        username: (profileData.proxy?.username) || '',
+        password: (profileData.proxy?.password) || '',
+      },
+      webRTC: profileData.webRTC || {},
+      screenHeight,
+      screenWidth,
+      userAgent: (profileData.navigator?.userAgent) || '',
+      webGl: {
+        vendor: (profileData.webGLMetadata?.vendor) || '',
+        renderer: (profileData.webGLMetadata?.renderer) || '',
+        mode: (profileData.webGLMetadata?.mode) === 'mask',
+      },
+      webgl: {
+        metadata: {
+          vendor: (profileData.webGLMetadata?.vendor) || '',
+          renderer: (profileData.webGLMetadata?.renderer) || '',
+          mode: (profileData.webGLMetadata?.mode) === 'mask',
+        },
+      },
+      mobile: {
+        enable: profileData.os === 'android',
+        width: profileData.screenWidth || 1920,
+        height: profileData.screenHeight || 1080,
+        device_scale_factor: profileData.devicePixelRatio || 1,
+      },
+      webglParams: profileData.webglParams || {},
+      webGpu: profileData.webGpu || {},
+      webgl_noice_enable: (profileData.webGL?.mode) === 'noise',
+      webglNoiceEnable: (profileData.webGL?.mode) === 'noise',
+      webgl_noise_enable: (profileData.webGL?.mode) === 'noise',
+      webgl_noise_value: profileData.webGL?.noise,
+      webglNoiseValue: profileData.webGL?.noise,
+      getClientRectsNoice: (profileData.clientRects?.noise) || (profileData.webGL?.getClientRectsNoise),
+      client_rects_noise_enable: (profileData.clientRects?.mode) === 'noise',
+      media_devices: {
+        enable: profileData.mediaDevices?.enableMasking,
+        uid: (profileData.mediaDevices?.uid) || '',
+        audioInputs: (profileData.mediaDevices?.audioInputs) || 1,
+        audioOutputs: (profileData.mediaDevices?.audioOutputs) || 1,
+        videoInputs: (profileData.mediaDevices?.videoInputs) || 1,
+      },
+      doNotTrack: (profileData.navigator?.doNotTrack) || false,
+      plugins: {
+        all_enable: profileData.plugins?.enableVulnerable,
+        flash_enable: profileData.plugins?.enableFlash,
+      },
+      storage: {
+        enable: profileData.storage?.local,
+      },
+      audioContext: {
+        enable: (profileData.audioContext?.mode) !== 'off',
+        noiseValue: (profileData.audioContext?.noise) || '',
+      },
+      canvas: {
+        mode: (profileData.canvas?.mode) || '',
+      },
+      languages: splittedLangs,
+      langHeader,
+      canvasMode: (profileData.canvas?.mode) || '',
+      canvasNoise: (profileData.canvas?.noise) || '',
+      deviceMemory: ((profileData.navigator?.deviceMemory) || 2) * 1024,
+      hardwareConcurrency: (profileData.navigator?.hardwareConcurrency) || 2,
+      startupUrl,
+      startup_urls: startupUrls,
+      geolocation: {
+        mode: (profileData.geolocation?.mode) || 'prompt',
+        latitude: parseFloat((this._tz && this._tz.ll && this._tz.ll[0]) || 0),
+        longitude: parseFloat((this._tz && this._tz.ll && this._tz.ll[1]) || 0),
+        accuracy: parseFloat((this._tz && this._tz.accuracy) || 0),
+      },
+      timezone: {
+        id: (this._tz && this._tz.timezone) || '',
+      },
     };
 
     return preferences;
@@ -420,6 +462,16 @@ export class GoLogin {
     await rimraf(profilePath, () => null);
     debug('-', profilePath, 'dropped');
     const profile = await this.getProfile();
+    if (!profile) {
+      throw new Error('Error fetching profile data');
+    }
+
+    if (!this.executablePath) {
+      const { userAgent } = profile.navigator;
+      const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
+      await this.checkBrowser(browserMajorVersion);
+    }
+
     const { navigator = {}, fonts, os: profileOs } = profile;
     this.fontsMasking = fonts?.enableMasking;
     this.profileOs = profileOs;
@@ -461,7 +513,6 @@ export class GoLogin {
     const preferences_raw = await readFile(pref_file_name);
     const preferences = JSON.parse(preferences_raw.toString());
     let proxy = get(profile, 'proxy');
-    const name = get(profile, 'name');
     const chromeExtensions = get(profile, 'chromeExtensions') || [];
     const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
     const allExtensions = [...chromeExtensions, ...userChromeExtensions];
@@ -554,60 +605,7 @@ export class GoLogin {
       throw new Error(`Proxy Error. ${e.message}`);
     });
 
-    const [latitude, longitude] = this._tz.ll;
-    const { accuracy } = this._tz;
-
-    const profileGeolocation = profile.geolocation;
-    const tzGeoLocation = {
-      latitude,
-      longitude,
-      accuracy,
-    };
-
-    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 = {
-      mode: get(profile, 'webRTC.mode') === 'alerted' ? 'public' : get(profile, 'webRTC.mode'),
-      publicIP: get(profile, 'webRTC.fillBasedOnIp') ? this._tz.ip : get(profile, 'webRTC.publicIp'),
-      localIps: get(profile, 'webRTC.localIps', []),
-    };
-
-    debug('profile.webRtc=', profile.webRtc);
-    debug('profile.timezone=', profile.timezone);
-    debug('profile.mediaDevices=', profile.mediaDevices);
-
-    const audioContext = profile.audioContext || {};
-    const { mode: audioCtxMode = 'off', noise: audioCtxNoise } = audioContext;
-    if (profile.timezone.fillBasedOnIp === false) {
-      profile.timezone = { id: profile.timezone.timezone };
-    } else {
-      profile.timezone = { id: this._tz.timezone };
-    }
-
-    profile.webgl_noise_value = profile.webGL.noise;
-    profile.get_client_rects_noise = profile.webGL.getClientRectsNoise;
-    profile.canvasMode = profile.canvas.mode;
-    profile.canvasNoise = profile.canvas.noise;
-    profile.audioContext = {
-      enable: audioCtxMode !== 'off',
-      noiseValue: audioCtxNoise,
-    };
-    profile.webgl = {
-      metadata: {
-        vendor: get(profile, 'webGLMetadata.vendor'),
-        renderer: get(profile, 'webGLMetadata.renderer'),
-        mode: get(profile, 'webGLMetadata.mode') === 'mask',
-      },
-    };
-
-    profile.custom_fonts = {
-      enable: !!fonts?.enableMasking,
-    };
-
-    const gologin = this.convertPreferences(profile);
+    const gologin = this.getGologinPreferences(profile);
 
     debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
     gologin.screenWidth = this.resolution.width;
@@ -632,19 +630,10 @@ export class GoLogin {
       }
     }
 
-    const languages = this.language.replace(/;|q=[\d\.]+/img, '');
-
     if (preferences.gologin == null) {
       preferences.gologin = {};
     }
 
-    preferences.gologin.langHeader = gologin.navigator.language;
-    preferences.gologin.language = languages;
-
-    const [splittedLangs] = gologin.navigator.language.split(';');
-    const [browserLang] = splittedLangs.split(',');
-    gologin.browserLang = browserLang;
-
     const isMAC = OS_PLATFORM === 'darwin';
     const checkAutoLangResult = checkAutoLang(gologin, this._tz);
     this.browserLang = isMAC ? 'en-US' : checkAutoLangResult;
@@ -755,9 +744,9 @@ export class GoLogin {
 
       const proxyUrl = `${proxy.mode}://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`;
       debug(`getTimeZone start ${TIMEZONE_URL}`, proxyUrl);
-      data = await requests.get(TIMEZONE_URL, { proxy: proxyUrl, timeout: 20 * 1000, maxAttempts: 5 });
+      data = await requests.get(TIMEZONE_URL, { proxy: proxyUrl, timeout: 13 * 1000, maxAttempts: 3 });
     } else {
-      data = await requests.get(TIMEZONE_URL, { timeout: 20 * 1000, maxAttempts: 5 });
+      data = await requests.get(TIMEZONE_URL, { timeout: 13 * 1000, maxAttempts: 3 });
     }
 
     debug('getTimeZone finish', data.body);
@@ -944,7 +933,7 @@ export class GoLogin {
 
     if (this.waitWebsocket) {
       debug('GETTING WS URL FROM BROWSER');
-      const data = await requests.get(`http://127.0.0.1:${remote_debugging_port}/json/version`, { json: true });
+      const data = await requests.get(`http://127.0.0.1:${remote_debugging_port}/json/version`, { json: true, maxAttempts: 10, retryDelay: 1000 });
 
       debug('WS IS', get(data, 'body.webSocketDebuggerUrl', ''));
       this.is_active = true;
@@ -1444,16 +1433,6 @@ export class GoLogin {
   }
 
   async start() {
-    if (!this.executablePath) {
-      await this.checkBrowser();
-    }
-
-    const ORBITA_BROWSER = this.executablePath || this.browserChecker.getOrbitaPath;
-
-    const orbitaBrowserExists = await access(ORBITA_BROWSER).then(() => true).catch(() => false);
-    if (!orbitaBrowserExists) {
-      throw new Error(`Orbita browser is not exists on path ${ORBITA_BROWSER}, check executablePath param`);
-    }
 
     await this.createStartup();
     // await this.createBrowserExtension();

package/src/utils/constants.js

@@ -1 +1 @@
-export const STORAGE_GATEWAY_BASE_URL = 'https://files-gateway.gologin.com';
+export const STORAGE_GATEWAY_BASE_URL = 'https://storage-worker-test.gologin.com';