gologin 1.0.35 → 1.0.38

package/gologin.js

@@ -123,7 +123,17 @@ class GoLogin {
   			'Authorization': `Bearer ${this.access_token}`
   		}
   	})
-    debug(profileResponse.body);
+    debug("profileResponse", profileResponse.statusCode, profileResponse.body);
+    
+    
+    if (profileResponse.statusCode === 404) {
+      throw new Error(JSON.parse(profileResponse.body).message);
+    }   
+
+    if (profileResponse.statusCode === 403) {
+      throw new Error(JSON.parse(profileResponse.body).message);
+    }   
+
   	if (profileResponse.statusCode !== 200) {
   		throw new Error(`Gologin /browser/${id} response error ${profileResponse.statusCode} INVALID TOKEN OR PROFILE NOT FOUND`);
   	}
@@ -132,6 +142,7 @@ class GoLogin {
       throw new Error("invalid token");
     }    
 
+
   	return JSON.parse(profileResponse.body);
   }
 
@@ -537,14 +548,22 @@ class GoLogin {
     let data = null;
     if (proxy!==null && proxy.mode !== "none") {
       if (proxy.mode.includes('socks')) {
-        return this.getTimezoneWithSocks(proxy);
+        for(let i=0; i<5; i++){
+          try{
+            debug('getting timeZone socks try', i+1);
+            return this.getTimezoneWithSocks(proxy);
+          } catch (e) {
+            console.log(e.message);
+          }
+        }
+        throw new Error(`Socks proxy connection timed out`);
       }
 
       const proxyUrl = `${proxy.mode}://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`;
-      debug('getTimeZone start https://time.gologin.com', proxyUrl);
-      data = await requests.get('https://time.gologin.com', { proxy: proxyUrl, timeout: 20 * 1000, maxAttempts: 5 });
+      debug('getTimeZone start https://time.gologin.com/timezone', proxyUrl);
+      data = await requests.get('https://time.gologin.com/timezone', { proxy: proxyUrl, timeout: 20 * 1000, maxAttempts: 5 });
     } else {
-      data = await requests.get('https://time.gologin.com', { timeout: 20 * 1000, maxAttempts: 5 });
+      data = await requests.get('https://time.gologin.com/timezone', { timeout: 20 * 1000, maxAttempts: 5 });
     }
     debug('getTimeZone finish', data.body);
     this._tz = JSON.parse(data.body);
@@ -1128,47 +1147,53 @@ class GoLogin {
 
   async startRemote(delay_ms = 10000) {
     debug(`startRemote ${this.profile_id}`);
+
+    /*
+    if (profileResponse.statusCode !== 202) {
+      return {'status': 'failure', 'code':  profileResponse.statusCode};
+    }
+    */
+    
+    // if (profileResponse.body === 'ok') {
+    const profile = await this.getProfile();
+
     const profileResponse = await requests.post(`https://api.gologin.com/browser/${this.profile_id}/web`, {
       headers: {
         'Authorization': `Bearer ${this.access_token}`
       }
     });
+    
+    debug('profileResponse', profileResponse.statusCode, profileResponse.body);
 
     if (profileResponse.statusCode === 401){
       throw new Error("invalid token");
     }
 
-    debug('profileResponse', profileResponse.statusCode, profileResponse.body);
-    if (profileResponse.statusCode !== 202) {
-      return {'status': 'failure', 'code':  profileResponse.statusCode};
-    }
-    
-    if (profileResponse.body === 'ok') {
-      const profile = await this.getProfile();
-      const { navigator = {}, fonts, os: profileOs  } = profile;
-      this.fontsMasking = fonts?.enableMasking;
-      this.profileOs = profileOs;
-      this.differentOs =
-        profileOs !== 'android' && (
-          OS_PLATFORM === 'win32' && profileOs !== 'win' ||
-          OS_PLATFORM === 'darwin' && profileOs !== 'mac' ||
-          OS_PLATFORM === 'linux' && profileOs !== 'lin'
-        );
-
-      const {
-        resolution = '1920x1080',
-        language = 'en-US,en;q=0.9',
-      } = navigator;
-      this.language = language;
-      const [screenWidth, screenHeight] = resolution.split('x');
-      this.resolution = {
-        width: parseInt(screenWidth, 10),
-        height: parseInt(screenHeight, 10),
-      };
+    const { navigator = {}, fonts, os: profileOs  } = profile;
+    this.fontsMasking = fonts?.enableMasking;
+    this.profileOs = profileOs;
+    this.differentOs =
+      profileOs !== 'android' && (
+        OS_PLATFORM === 'win32' && profileOs !== 'win' ||
+        OS_PLATFORM === 'darwin' && profileOs !== 'mac' ||
+        OS_PLATFORM === 'linux' && profileOs !== 'lin'
+      );
+
+    const {
+      resolution = '1920x1080',
+      language = 'en-US,en;q=0.9',
+    } = navigator;
+    this.language = language;
+    const [screenWidth, screenHeight] = resolution.split('x');
+    this.resolution = {
+      width: parseInt(screenWidth, 10),
+      height: parseInt(screenHeight, 10),
+    };
 
-      let wsUrl = await this.waitDebuggingUrl(delay_ms);
+    let wsUrl = await this.waitDebuggingUrl(delay_ms);
+    if(wsUrl!=''){
       return { 'status': 'success', wsUrl }
-    }
+    } 
 
     return { 'status': 'failure', 'message': profileResponse.body };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin",
-  "version": "1.0.35",
+  "version": "1.0.38",
   "description": "A high-level API to control Orbita browser over GoLogin API",
   "main": "./gologin.js",
   "repository": {
@@ -15,7 +15,6 @@
   "dependencies": {
     "archiver": "^3.1.1",
     "child_process": "^1.0.2",
-    "chromedriver": "^89.0.0",
     "decompress": "^4.2.1",
     "decompress-unzip": "^4.0.1",
     "form-data": "^3.0.0",
@@ -25,7 +24,6 @@
     "request": "^2.88.2",
     "requestretry": "^4.1.0",
     "rimraf": "^3.0.2",
-    "selenium-webdriver": "^4.0.0-alpha.7",
     "simple-proxy-agent": "^1.1.0",
     "sqlite": "^4.0.23",
     "sqlite3": "^5.0.2",

package/selenium/example.js

@@ -1,32 +0,0 @@
-const GoLogin = require('../gologin');
-const webdriver = require("selenium-webdriver");
-const chrome = require("selenium-webdriver/chrome");
-chrome.setDefaultService(new chrome.ServiceBuilder('./chromedriver').build());
- 
-
-(async () =>{
-    const GL = new GoLogin({
-        token: 'yU0token',
-        profile_id: 'yU0Pr0f1leiD',
-        executablePath: '/usr/bin/orbita-browser/chrome',
-    });
-    console.log('creating startup')
-    await GL.createStartup();
-    console.log('spawn arguments')
-    const arguments = await GL.spawnArguments();
-    console.log('set options')
-    const chromeOptions = new chrome.Options();
-    arguments.forEach((e) => {
-      console.log('e=', e);
-      chromeOptions.addArguments(e)
-    });
-
-    chromeOptions.setChromeBinaryPath('/usr/bin/orbita-browser/chrome');
-
-    driver = new webdriver.Builder()
-                 .forBrowser("chrome")
-                 .setChromeOptions(chromeOptions)
-                 .build();
-
-    await driver.get('https://myip.link')
-})();

package/selenium/gologin-create-profile.py

@@ -1,30 +0,0 @@
-from gologin import GoLogin
-
-
-gl = GoLogin({
-	"token": "yU0token",
-	})
-
-profile_id = gl.create({
-    "name": 'profile_mac',
-    "os": 'mac',
-    "navigator": {
-        "language": 'enUS',
-        "userAgent": 'MyUserAgent', 
-        "resolution": '1024x768',
-        "platform": 'mac',
-    }
-});
-
-print('profile id=', profile_id);
-
-gl.update({
-    "id": profile_id,
-    "name": 'profile_mac2',
-});
-
-profile = gl.getProfile(profile_id);
-
-print('new profile name=', profile.get("name"));
-
-gl.delete(profile_id)

package/selenium/gologin-local.py

@@ -1,30 +0,0 @@
-import time
-from sys import platform
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from gologin import GoLogin
-
-
-gl = GoLogin({
-	"token": "yU0token",
-	"profile_id": "yU0Pr0f1leiD",
-	"local": True,
-	"credentials_enable_service": False,
-	})
-
-if platform == "linux" or platform == "linux2":
-	chrome_driver_path = "./chromedriver"
-elif platform == "darwin":
-	chrome_driver_path = "./mac/chromedriver"
-elif platform == "win32":
-	chrome_driver_path = "chromedriver.exe"
-
-debugger_address = gl.start()
-chrome_options = Options()
-chrome_options.add_experimental_option("debuggerAddress", debugger_address)
-driver = webdriver.Chrome(executable_path=chrome_driver_path, options=chrome_options)
-driver.get("http://www.python.org")
-assert "Python" in driver.title
-driver.close()
-time.sleep(3)
-gl.stop()

package/selenium/gologin-selenium-multiprocess.py

@@ -1,50 +0,0 @@
-import time
-import os
-from multiprocessing import Pool
-from sys import platform
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from gologin import GoLogin
-
-def scrap(profile):
-	gl = GoLogin({
-	        'token': 'yU0token',
-	        'profile_id': profile['profile_id'],
-	        'port': profile['port'],
-		})
-
-	if platform == "linux" or platform == "linux2":
-		chrome_driver_path = './chromedriver'
-	elif platform == "darwin":
-		chrome_driver_path = './mac/chromedriver'
-	elif platform == "win32":
-		chrome_driver_path = 'chromedriver.exe'
-
-	debugger_address = gl.start()
-	chrome_options = Options()
-	chrome_options.add_experimental_option("debuggerAddress", debugger_address)
-	driver = webdriver.Chrome(executable_path=chrome_driver_path, options=chrome_options)
-	driver.get("http://www.python.org")
-	print('ready', profile['profile_id'], driver.title)
-	time.sleep(10)
-	print('closing', profile['profile_id'])
-	driver.close()
-	gl.stop()
-
-profiles = [
-	{'profile_id': 'profile_id_1', 'port': 3500}, 
-	{'profile_id': 'profile_id_2', 'port': 3501},
-	{'profile_id': 'profile_id_3', 'port': 3502},
-	]
-
-
-with Pool(3) as p:
-	p.map(scrap, profiles)
-
-
-if platform == "win32":
-	os.system('taskkill /im chrome.exe /f')
-	os.system('taskkill /im chromedriver.exe /f')
-else:
-	os.system('killall -9 chrome')
-	os.system('killall -9 chromedriver')

package/selenium/gologin-selenium.py

@@ -1,28 +0,0 @@
-import time
-from sys import platform
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from gologin import GoLogin
-
-
-gl = GoLogin({
-	"token": "yU0token",
-	"profile_id": "yU0Pr0f1leiD",
-	})
-
-if platform == "linux" or platform == "linux2":
-	chrome_driver_path = "./chromedriver"
-elif platform == "darwin":
-	chrome_driver_path = "./mac/chromedriver"
-elif platform == "win32":
-	chrome_driver_path = "chromedriver.exe"
-
-debugger_address = gl.start()
-chrome_options = Options()
-chrome_options.add_experimental_option("debuggerAddress", debugger_address)
-driver = webdriver.Chrome(executable_path=chrome_driver_path, options=chrome_options)
-driver.get("http://www.python.org")
-assert "Python" in driver.title
-driver.close()
-time.sleep(3)
-gl.stop()

package/selenium/gologin.py

@@ -1,458 +0,0 @@
-import json
-import time
-import os
-import stat
-import sys
-import shutil
-import requests
-import zipfile
-import subprocess
-import pathlib
-import tempfile
-
-API_URL = 'https://api.gologin.com'
-
-class GoLogin(object):
-    def __init__(self, options):
-        self.access_token = options.get('token')
-
-        self.tmpdir = options.get('tmpdir', tempfile.gettempdir())
-        self.address = options.get('address', '127.0.0.1')
-        self.extra_params = options.get('extra_params', [])
-        self.port  = options.get('port', 3500)
-        self.local = options.get('local', False)
-        self.spawn_browser = options.get('spawn_browser', True)
-        self.credentials_enable_service = options.get('credentials_enable_service')
-
-        home = str(pathlib.Path.home())
-        self.executablePath = options.get('executablePath', os.path.join(home, '.gologin/browser/orbita-browser/chrome'))
-        print('executablePath', self.executablePath)
-        if self.extra_params:
-            print('extra_params', self.extra_params)
-        self.setProfileId(options.get('profile_id')) 
-
-
-    def setProfileId(self, profile_id):
-        self.profile_id = profile_id
-        if self.profile_id==None:
-            return
-        self.profile_path = os.path.join(self.tmpdir, 'gologin_'+self.profile_id)
-        self.profile_zip_path = os.path.join(self.tmpdir, 'gologin_'+self.profile_id+'.zip')
-        self.profile_zip_path_upload = os.path.join(self.tmpdir, 'gologin_'+self.profile_id+'_upload.zip')
-
-
-    def spawnBrowser(self):
-        proxy = self.proxy
-        proxy_host = ''
-        if proxy:
-            if proxy.get('mode')==None or proxy.get('mode')=='geolocation':
-                proxy['mode'] = 'http'
-            proxy_host = proxy.get('host')            
-            proxy = self.formatProxyUrl(proxy)
-        
-        tz = self.tz.get('timezone')
-
-        params = [
-        self.executablePath,
-        '--remote-debugging-port='+str(self.port),
-        '--user-data-dir='+self.profile_path, 
-        '--password-store=basic', 
-        '--tz='+tz, 
-        '--gologin-profile='+self.profile_name, 
-        '--lang=en', 
-        ]    
-        if proxy:
-            hr_rules = '"MAP * 0.0.0.0 , EXCLUDE %s"'%(proxy_host)
-            params.append('--proxy-server='+proxy)
-            params.append('--host-resolver-rules='+hr_rules)
-
-        for param in self.extra_params:
-            params.append(param)
-
-        if sys.platform == "darwin":
-            subprocess.Popen(params)
-        else:
-            subprocess.Popen(params, start_new_session=True)
-
-        try_count = 1
-        url = str(self.address) + ':' + str(self.port)
-        while try_count<100:
-            try:
-                data = requests.get('http://'+url+'/json').content
-                break
-            except:
-                try_count += 1
-                time.sleep(1)
-        
-        return url
-
-    def start(self):
-        profile_path = self.createStartup()
-        if self.spawn_browser == True:
-            return self.spawnBrowser()
-        return profile_path
-
-    def zipdir(self, path, ziph):
-        for root, dirs, files in os.walk(path):
-            for file in files:
-                path = os.path.join(root, file)
-                if not os.path.exists(path):
-                    continue
-                if stat.S_ISSOCK(os.stat(path).st_mode):
-                    continue
-                try:
-                    ziph.write(path, path.replace(self.profile_path, ''))
-                except:
-                    continue
-
-    def stop(self):
-        self.sanitizeProfile()
-        if self.local==False:
-            self.commitProfile()
-            os.remove(self.profile_zip_path_upload)
-            shutil.rmtree(self.profile_path)
-
-    def commitProfile(self):
-        zipf = zipfile.ZipFile(self.profile_zip_path_upload, 'w', zipfile.ZIP_DEFLATED)
-        self.zipdir(self.profile_path, zipf)
-        zipf.close()
-        
-        headers = {
-            'Authorization': 'Bearer ' + self.access_token,
-            'User-Agent': 'Selenium-API'
-        }
-        # print('profile size=', os.stat(self.profile_zip_path_upload).st_size)
-
-        signedUrl = requests.get(API_URL + '/browser/' + self.profile_id + '/storage-signature', headers=headers).content.decode('utf-8')
-
-        requests.put(signedUrl, data=open(self.profile_zip_path_upload, 'rb'))
-
-        # print('commit profile complete')
-
-
-    def sanitizeProfile(self):
-        remove_dirs = [
-          'Default/Cache',
-          'Default/Service Worker/CacheStorage',
-          'Default/Code Cache',
-          'Default/GPUCache',
-          'GrShaderCache',
-          'ShaderCache',
-          'biahpgbdmdkfgndcmfiipgcebobojjkp',
-          'afalakplffnnnlkncjhbmahjfjhmlkal',
-          'cffkpbalmllkdoenhmdmpbkajipdjfam',
-          'Dictionaries',
-          'enkheaiicpeffbfgjiklngbpkilnbkoi',
-          'oofiananboodjbbmdelgdommihjbkfag',
-          'SafetyTips',
-          'fonts',
-        ];
-
-        for d in remove_dirs:
-            fpath = os.path.join(self.profile_path, d)
-            if os.path.exists(fpath):
-                try:
-                    shutil.rmtree(fpath)
-                except:
-                    continue
-    
-    def formatProxyUrl(self, proxy):
-        return proxy.get('mode', 'http')+'://'+proxy.get('host','')+':'+str(proxy.get('port',80))
-
-    def formatProxyUrlPassword(self, proxy):
-        if proxy.get('username', '')=='':
-            return proxy.get('mode', 'http')+'://'+proxy.get('host','')+':'+str(proxy.get('port',80))
-        else:
-            return proxy.get('mode', 'http')+'://'+proxy.get('username','')+':'+proxy.get('password')+'@'+proxy.get('host','')+':'+str(proxy.get('port',80))
-
-
-    def getTimeZone(self):
-        proxy = self.proxy
-        if proxy:            
-            proxies = {proxy.get('mode'): self.formatProxyUrlPassword(proxy)}
-            data = requests.get('https://time.gologin.com', proxies=proxies)
-        else:
-            data = requests.get('https://time.gologin.com')
-        return json.loads(data.content.decode('utf-8'))
-
-
-    def getProfile(self, profile_id=None):
-        profile = self.profile_id if profile_id==None else profile_id
-        headers = {
-            'Authorization': 'Bearer ' + self.access_token,
-            'User-Agent': 'Selenium-API'
-        }
-        return json.loads(requests.get(API_URL + '/browser/' + profile, headers=headers).content.decode('utf-8'))
-
-    def downloadProfileZip(self):
-        s3path = self.profile.get('s3Path', '')
-        data = ''
-        if s3path=='':
-            # print('downloading profile direct')
-            headers = {
-                'Authorization': 'Bearer ' + self.access_token,
-                'User-Agent': 'Selenium-API'
-            }
-            data = requests.get(API_URL + '/browser/'+self.profile_id, headers=headers).content
-        else:
-            # print('downloading profile s3')
-            s3url = 'https://gprofiles.gologin.com/' + s3path.replace(' ', '+')
-            data = requests.get(s3url).content
-
-        if len(data)==0:
-            self.createEmptyProfile()            
-        else:
-            with open(self.profile_zip_path, 'wb') as f:
-                f.write(data)
-        
-        try:
-            self.extractProfileZip()
-        except:
-            self.createEmptyProfile()   
-            self.extractProfileZip()
-
-        if not os.path.exists(os.path.join(self.profile_path, 'Default/Preferences')):
-            self.createEmptyProfile()   
-            self.extractProfileZip()
-
-
-    def createEmptyProfile(self):
-        print('createEmptyProfile')
-        empty_profile = '../gologin_zeroprofile.zip'
-        if not os.path.exists(empty_profile):
-            empty_profile = 'gologin_zeroprofile.zip'
-        shutil.copy(empty_profile, self.profile_zip_path)
-
-    def extractProfileZip(self):
-        with zipfile.ZipFile(self.profile_zip_path, 'r') as zip_ref:
-            zip_ref.extractall(self.profile_path)       
-        os.remove(self.profile_zip_path)
-
-
-    def getGeolocationParams(self, profileGeolocationParams, tzGeolocationParams):
-        if profileGeolocationParams.get('fillBasedOnIp'):
-          return {
-            'mode': profileGeolocationParams['mode'],
-            'latitude': float(tzGeolocationParams['latitude']),
-            'longitude': float(tzGeolocationParams['longitude']),
-            'accuracy': float(tzGeolocationParams['accuracy']),
-          }
-        
-        return {
-          'mode': profileGeolocationParams['mode'],
-          'latitude': profileGeolocationParams['latitude'],
-          'longitude': profileGeolocationParams['longitude'],
-          'accuracy': profileGeolocationParams['accuracy'],
-        }
-
-
-    def convertPreferences(self, preferences):
-        resolution = preferences.get('resolution', '1920x1080')
-        preferences['screenWidth'] = int(resolution.split('x')[0])
-        preferences['screenHeight'] = int(resolution.split('x')[1])
-        
-        self.tz = self.getTimeZone()
-        # print('tz=', self.tz)
-        tzGeoLocation = {
-            'latitude': self.tz.get('ll', [0, 0])[0],
-            'longitude': self.tz.get('ll', [0, 0])[1],
-            'accuracy': self.tz.get('accuracy', 0),
-        }
-
-        preferences['geoLocation'] = self.getGeolocationParams(preferences['geolocation'], tzGeoLocation)
-
-        preferences['webRtc'] = {
-            'mode': 'public' if preferences.get('webRTC',{}).get('mode') == 'alerted' else preferences.get('webRTC',{}).get('mode'),
-            'publicIP': self.tz['ip'] if preferences.get('webRTC',{}).get('fillBasedOnIp') else preferences.get('webRTC',{}).get('publicIp'),
-            'localIps': preferences.get('webRTC',{}).get('localIps', [])
-        }
-
-        preferences['timezone'] = {
-            'id': self.tz.get('timezone')
-        }
-
-        preferences['webgl_noise_value'] = preferences.get('webGL', {}).get('noise')
-        preferences['get_client_rects_noise'] = preferences.get('webGL', {}).get('getClientRectsNoise')
-        preferences['canvasMode'] = preferences.get('canvas', {}).get('mode')
-        preferences['canvasNoise'] = preferences.get('canvas', {}).get('noise')
-        preferences['audioContext'] = {
-            'enable': preferences.get('audioContext').get('mode', 'off'),
-            'noiseValue': preferences.get('audioContext').get('noise'),
-        }
-
-        preferences['webgl'] = {
-            'metadata': {
-              'vendor': preferences.get('webGLMetadata', {}).get('vendor'),
-              'renderer': preferences.get('webGLMetadata', {}).get('renderer'),
-              'mode': preferences.get('webGLMetadata', {}).get('mode') == 'mask',
-            }
-        }
-
-        if preferences.get('navigator', {}).get('userAgent'):
-            preferences['userAgent'] = preferences.get('navigator', {}).get('userAgent')
-
-        if preferences.get('navigator', {}).get('doNotTrack'):
-            preferences['doNotTrack'] = preferences.get('navigator', {}).get('doNotTrack')
-        
-        if preferences.get('navigator', {}).get('hardwareConcurrency'):
-            preferences['hardwareConcurrency'] = preferences.get('navigator', {}).get('hardwareConcurrency')
-
-        if preferences.get('navigator', {}).get('language'):
-            preferences['language'] = preferences.get('navigator', {}).get('language')
-
-        return preferences
-
-
-    def updatePreferences(self):
-        pref_file = os.path.join(self.profile_path, 'Default/Preferences')
-        with open(pref_file, 'r', encoding="utf-8") as pfile:
-            preferences = json.load(pfile)    
-        profile = self.profile
-        proxy = self.profile.get('proxy')
-        # print('proxy=', proxy)
-        if proxy and (proxy.get('mode')=='gologin' or proxy.get('mode')=='tor'):
-            autoProxyServer = profile.get('autoProxyServer')
-            splittedAutoProxyServer = autoProxyServer.split('://')
-            splittedProxyAddress = splittedAutoProxyServer[1].split(':')
-            port = splittedProxyAddress[1]
-
-            proxy = {
-              'mode': 'http',
-              'host': splittedProxyAddress[0],
-              'port': port,
-              'username': profile.get('autoProxyUsername'),
-              'password': profile.get('autoProxyPassword'),
-              'timezone': profile.get('autoProxyTimezone', 'us'),
-            }
-            
-            profile['proxy']['username'] = profile.get('autoProxyUsername')
-            profile['proxy']['password'] = profile.get('autoProxyPassword')
-        
-        if not proxy or proxy.get('mode')=='none':
-            print('no proxy')
-            proxy = None
-        
-        if proxy and proxy.get('mode')==None:
-            proxy['mode'] = 'http'
-
-        self.proxy = proxy
-        self.profile_name = profile.get('name')
-        if self.profile_name==None:
-            print('empty profile name')
-            print('profile=', profile)
-            exit()
-
-        gologin = self.convertPreferences(profile)
-        if self.credentials_enable_service!=None:
-            preferences['credentials_enable_service'] = self.credentials_enable_service
-        preferences['gologin'] = gologin
-        pfile = open(pref_file, 'w')
-        json.dump(preferences, pfile)
-
-    def createStartup(self):
-        if self.local==False and os.path.exists(self.profile_path):
-            shutil.rmtree(self.profile_path)
-        self.profile = self.getProfile()
-        if self.local==False:
-            self.downloadProfileZip()
-        self.updatePreferences()
-        return self.profile_path
-
-
-    def headers(self):
-        return {
-            'Authorization': 'Bearer ' + self.access_token,
-            'User-Agent': 'Selenium-API'
-        }
-
-
-    def getRandomFingerprint(self, options):
-        os_type = options.get('os', 'lin')
-        return json.loads(requests.get(API_URL + '/browser/fingerprint?os=' + os_type, headers=self.headers()).content.decode('utf-8'))
-
-    def profiles(self):
-        return json.loads(requests.get(API_URL + '/browser/v2', headers=self.headers()).content.decode('utf-8'))
-
-    def create(self, options={}):
-        profile_options = self.getRandomFingerprint(options)
-        profile = {
-          "name": "default_name",
-          "notes": "auto generated",
-          "browserType": "chrome",
-          "os": "lin",
-          "startUrl": "google.com",
-          "googleServicesEnabled": True,
-          "lockEnabled": False,
-          "audioContext": {
-            "mode": "noise"
-          },
-          "canvas": {
-            "mode": "noise"
-          },
-          "webRTC": {
-            "mode": "disabled",
-            "enabled": False,
-            "customize": True,
-            "fillBasedOnIp": True
-          },
-          "navigator": profile_options.get('navigator', {}),
-          "screenHeight": 768,
-          "screenWidth": 1024,
-          "proxyEnabled": True,
-          "profile": json.dumps(profile_options),
-        }
-    
-        if profile.get('navigator'):
-          profile['navigator']['resolution'] = "1024x768"
-        else:
-          profile['navigator'] = {'resolution': "1024x768"}
-        
-        for k,v in options.items():
-            profile[k] = v
-
-        response = json.loads(requests.post(API_URL + '/browser/', headers=self.headers(), json=profile).content.decode('utf-8'))
-        return response.get('id')
-
-
-    def delete(self, profile_id=None):
-        profile = self.profile_id if profile_id==None else profile_id
-        requests.delete(API_URL + '/browser/' + profile, headers=self.headers())
-
-
-    def update(self, options):
-        self.profile_id = options.get('id')
-        profile = self.getProfile()
-        #print("profile", profile)
-        for k,v in options.items():
-            profile[k] = v
-        resp = requests.put(API_URL + '/browser/' + self.profile_id, headers=self.headers(), json=profile).content.decode('utf-8')
-        #print("update", resp)
-        #return json.loads(resp)
-
-    def waitDebuggingUrl(self, delay_s, try_count=3):
-        url = 'https://' + self.profile_id + '.orbita.gologin.com/json/version'
-        wsUrl = ''
-        try_number = 1
-        while wsUrl=='':
-            time.sleep(delay_s)
-            try:
-                response = json.loads(requests.get(url).content)
-                wsUrl = response.get('webSocketDebuggerUrl', '')
-            except:
-                pass
-            if try_number >= try_count:
-                return {'status': 'failure', 'wsUrl': wsUrl}
-            try_number += 1
-
-        wsUrl = wsUrl.replace('ws://', 'wss://').replace('127.0.0.1', self.profile_id + '.orbita.gologin.com')
-        return {'status': 'success', 'wsUrl': wsUrl}
-
-    def startRemote(self, delay_s=3):
-        profileResponse = requests.post(API_URL + '/browser/' + self.profile_id + '/web', headers=self.headers()).content.decode('utf-8')
-        print('profileResponse', profileResponse)
-        if profileResponse == 'ok':
-            return self.waitDebuggingUrl(delay_s)
-        return {'status': 'failure'}
-
-    def stopRemote(self):
-        requests.delete(API_URL + '/browser/' + self.profile_id + '/web', headers=self.headers())