gologin 2.1.19 → 2.1.21

package/src/gologin-api.js

@@ -1,17 +1,20 @@
 import puppeteer from 'puppeteer-core';
 
 import GoLogin from './gologin.js';
+import { API_URL, getOsAdvanced } from './utils/common.js';
 
-export function getDefaultParams() {
-  return {
-    token: process.env.GOLOGIN_API_TOKEN,
-    profile_id: process.env.GOLOGIN_PROFILE_ID,
-    executablePath: process.env.GOLOGIN_EXECUTABLE_PATH,
-    autoUpdateBrowser: true,
-  };
-}
+const trafficLimitMessage =
+  'You dont have free traffic to use the proxy. Please go to app https://app.gologin.com/ and buy some traffic if you want to use the proxy';
 
-const createLegacyGologin = ({ profileId, ...params }) => {
+export const getDefaultParams = () => ({
+  token: process.env.GOLOGIN_API_TOKEN,
+  profile_id: process.env.GOLOGIN_PROFILE_ID,
+  executablePath: process.env.GOLOGIN_EXECUTABLE_PATH,
+  autoUpdateBrowser: true,
+});
+
+const createGologinProfileManager = ({ profileId, ...params }) => {
+  console.log({ params });
   const defaults = getDefaultParams();
   const mergedParams = {
     ...defaults,
@@ -27,9 +30,7 @@ const createLegacyGologin = ({ profileId, ...params }) => {
 
 const createdApis = [];
 
-export const delay = (ms = 250) => new Promise((res) => setTimeout(res, ms));
-
-export function GologinApi({ token }) {
+export const GologinApi = ({ token }) => {
   if (!token) {
     throw new Error('GoLogin API token is missing');
   }
@@ -38,7 +39,7 @@ export function GologinApi({ token }) {
   const legacyGls = [];
 
   const launchLocal = async (params) => {
-    const legacyGologin = createLegacyGologin({
+    const legacyGologin = createGologinProfileManager({
       ...params,
       token,
     });
@@ -48,9 +49,9 @@ export function GologinApi({ token }) {
       await legacyGologin.setProfileId(id);
     }
 
-    const started = await legacyGologin.start();
+    const startedProfile = await legacyGologin.start();
     const browser = await puppeteer.connect({
-      browserWSEndpoint: started.wsUrl,
+      browserWSEndpoint: startedProfile.wsUrl,
       ignoreHTTPSErrors: true,
     });
 
@@ -61,7 +62,7 @@ export function GologinApi({ token }) {
   };
 
   const launchCloudProfile = async (params) => {
-    const legacyGologin = createLegacyGologin({
+    const legacyGologin = createGologinProfileManager({
       ...params,
       token,
     });
@@ -87,6 +88,7 @@ export function GologinApi({ token }) {
 
   const api = {
     async launch(params = {}) {
+      console.log();
       if (params.cloud) {
         return launchCloudProfile(params);
       }
@@ -94,7 +96,207 @@ export function GologinApi({ token }) {
       return launchLocal(params);
     },
 
-    async exit(status = 0) {
+    async createProfileWithCustomParams(options) {
+      const response = await fetch(`${API_URL}/browser/custom`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+        },
+        body: JSON.stringify(options),
+      });
+
+      if (response.status === 400) {
+        throw new Error(`gologin failed account creation with status code, ${response.status} DATA  ${JSON.stringify(await response.json())}`);
+      }
+
+      if (response.status === 500) {
+        throw new Error(`gologin failed account creation with status code, ${response.status}`);
+      }
+
+      const profile = await response.json();
+
+      return profile.id;
+    },
+
+    async refreshProfilesFingerprint(profileIds) {
+      if (!profileIds) {
+        throw new Error('Profile ID is required');
+      }
+
+      const response = await fetch(`${API_URL}/browser/fingerprints`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        body: JSON.stringify({ browsersIds: profileIds }),
+      });
+
+      return response.json();
+    },
+
+    async createProfileRandomFingerprint(name = '') {
+      const osInfo = await getOsAdvanced();
+      const { os, osSpec } = osInfo;
+      const resultName = name || 'api-generated';
+
+      const response = await fetch(`${API_URL}/browser/quick`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          os,
+          osSpec,
+          name: resultName,
+        }),
+      });
+
+      return response.json();
+    },
+
+    async updateUserAgentToLatestBrowser(profileIds, workspaceId = '') {
+      let url = `${API_URL}/browser/update_ua_to_new_browser_v`;
+      if (workspaceId) {
+        url += `?currentWorkspace=${workspaceId}`;
+      }
+
+      const response = await fetch(url, {
+        method: 'PATCH',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ browserIds: profileIds, updateUaToNewBrowserV: true, updateAllProfiles: false, testOrbita: false }),
+      });
+
+      return response.json();
+    },
+
+    async changeProfileProxy(profileId, proxyData) {
+      console.log(proxyData);
+      const response = await fetch(`${API_URL}/browser/${profileId}/proxy`, {
+        method: 'PATCH',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(proxyData),
+      });
+
+      return response.status;
+    },
+
+    getAvailableType(availableTrafficData) {
+      switch (true) {
+        case availableTrafficData.mobileTrafficData.trafficUsedBytes > availableTrafficData.mobileTrafficData.trafficLimitBytes:
+          return 'mobile';
+        case availableTrafficData.residentialTrafficData.trafficUsedBytes < availableTrafficData.residentialTrafficData.trafficLimitBytes:
+          return 'resident';
+        case availableTrafficData.dataCenterTrafficData.trafficUsedBytes < availableTrafficData.dataCenterTrafficData.trafficLimitBytes:
+          return 'dataCenter';
+        default:
+          return 'none';
+      }
+    },
+
+    async addGologinProxyToProfile(profileId, countryCode, proxyType = '') {
+      if (!proxyType) {
+        const availableTraffic = await fetch(`${API_URL}/users-proxies/geolocation/traffic`, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'user-agent': 'gologin-api',
+            'Content-Type': 'application/json',
+          },
+        });
+
+        const availableTrafficData = await availableTraffic.json();
+        console.log(availableTrafficData);
+        const availableType = this.getAvailableType(availableTrafficData);
+        if (availableType === 'none') {
+          throw new Error(trafficLimitMessage);
+        }
+
+        console.log(availableType);
+        proxyType = availableType;
+      }
+
+      let isDc = false;
+      let isMobile = false;
+
+      switch (proxyType) {
+        case 'mobile':
+          isMobile = true;
+          isDc = false;
+          break;
+        case 'resident':
+          isMobile = false;
+          isDc = false;
+          break;
+        case 'dataCenter':
+          isMobile = false;
+          isDc = true;
+          break;
+        default:
+          throw new Error('Invalid proxy type');
+      }
+
+      const proxyResponse = await fetch(`${API_URL}/users-proxies/mobile-proxy`, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        body: JSON.stringify({
+          countryCode,
+          isDc,
+          isMobile,
+          profileIdToLink: profileId,
+        }),
+      });
+
+      const proxy = await proxyResponse.json();
+      if (proxy.trafficLimitBytes < proxy.trafficUsedBytes) {
+        throw new Error(trafficLimitMessage);
+      }
+
+      return proxy;
+    },
+
+    async addCookiesToProfile(profileId, cookies) {
+      const response = await fetch(`${API_URL}/browser/${profileId}/cookies?fromUser=true`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(cookies),
+      });
+
+      return response.status;
+    },
+
+    async deleteProfile(profileId) {
+      const response = await fetch(`${API_URL}/browser/${profileId}`, {
+        method: 'DELETE',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+        },
+      });
+
+      return response.status;
+    },
+
+    async exit() {
       Promise.allSettled(browsers.map((browser) => browser.close()));
       Promise.allSettled(
         legacyGls.map((gl) => gl.stopLocal({ posting: false })),
@@ -103,14 +305,12 @@ export function GologinApi({ token }) {
         legacyGls.map((gl) => gl.stopRemote({ posting: true })),
       );
     },
-
-    delay,
   };
 
   createdApis.push(api);
 
   return api;
-}
+};
 
 export function exitAll() {
   Promise.allSettled(createdApis.map((api) => api.exit()));

package/src/gologin.js

@@ -116,36 +116,6 @@ export class GoLogin {
     }
   }
 
-  async getNewFingerPrint(os) {
-    debug('GETTING FINGERPRINT');
-
-    const fpResponse = await requests.get(`${API_URL}/browser/fingerprint?os=${os}`, {
-      json: true,
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-    });
-
-    return fpResponse?.body || {};
-  }
-
-  async profiles() {
-    const profilesResponse = await requests.get(`${API_URL}/browser/v2`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-
-      },
-    });
-
-    if (profilesResponse.statusCode !== 200) {
-      throw new Error('Gologin /browser response error');
-    }
-
-    return JSON.parse(profilesResponse.body);
-  }
-
   async getProfile(profile_id) {
     const id = profile_id || this.profile_id;
     debug('getProfile', this.access_token, id);
@@ -1235,48 +1205,6 @@ export class GoLogin {
     return response.body.id;
   }
 
-  async createCustom(options) {
-    debug('createCustomProfile', options);
-    const response = await requests.post(`${API_URL}/browser/custom`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: options,
-    });
-
-    if (response.statusCode === 400) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode} DATA  ${JSON.stringify(response.body.message)}`);
-    }
-
-    if (response.statusCode === 500) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode}`);
-    }
-
-    debug(JSON.stringify(response));
-
-    return response.body.id;
-  }
-
-  async quickCreateProfile(name = '') {
-    const osInfo = await getOsAdvanced();
-    const { os, osSpec } = osInfo;
-    const resultName = name || 'api-generated';
-
-    return requests.post(`${API_URL}/browser/quick`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: {
-        os,
-        osSpec,
-        name: resultName,
-      },
-    })
-      .then(res => res.body);
-  }
-
   async delete(pid) {
     const profile_id = pid || this.profile_id;
     await requests.delete(`${API_URL}/browser/${profile_id}`, {
@@ -1452,7 +1380,6 @@ export class GoLogin {
   }
 
   async start() {
-
     await this.createStartup();
     // await this.createBrowserExtension();
     const wsUrl = await this.spawnBrowser();
@@ -1525,22 +1452,72 @@ export class GoLogin {
     }
   }
 
+  // api for users to manage their profiles
+  async changeProfileProxy(proxyData) {
+    return updateProfileProxy(this.profile_id, this.access_token, proxyData);
+  }
+
+  async changeProfileUserAgent(userAgent) {
+    return updateProfileUserAgent(this.profile_id, this.access_token, userAgent);
+  }
+
+  async changeProfileResolution(resolution) {
+    return updateProfileResolution(this.profile_id, this.access_token, resolution);
+  }
+
   getAvailableFonts() {
     return fontsCollection
       .filter(elem => elem.fileNames)
       .map(elem => elem.name);
   }
 
-  async changeProfileResolution(resolution) {
-    return updateProfileResolution(this.profile_id, this.access_token, resolution);
+  async quickCreateProfile(name = '') {
+    const osInfo = await getOsAdvanced();
+    const { os, osSpec } = osInfo;
+    const resultName = name || 'api-generated';
+
+    return requests.post(`${API_URL}/browser/quick`, {
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+      },
+      json: {
+        os,
+        osSpec,
+        name: resultName,
+      },
+    })
+      .then(res => res.body);
   }
 
-  async changeProfileUserAgent(userAgent) {
-    return updateProfileUserAgent(this.profile_id, this.access_token, userAgent);
+  async profiles() {
+    const profilesResponse = await requests.get(`${API_URL}/browser/v2`, {
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+
+      },
+    });
+
+    if (profilesResponse.statusCode !== 200) {
+      throw new Error('Gologin /browser response error');
+    }
+
+    return JSON.parse(profilesResponse.body);
   }
 
-  async changeProfileProxy(proxyData) {
-    return updateProfileProxy(this.profile_id, this.access_token, proxyData);
+  async getNewFingerPrint(os) {
+    debug('GETTING FINGERPRINT');
+
+    const fpResponse = await requests.get(`${API_URL}/browser/fingerprint?os=${os}`, {
+      json: true,
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+      },
+    });
+
+    return fpResponse?.body || {};
   }
 }
 

package/src/utils/utils.js

@@ -47,3 +47,4 @@ export const findLatestBrowserVersionDirectory = (browserPath) => {
   return folderName;
 };
 
+export const delay = (ms = 250) => new Promise((res) => setTimeout(res, ms));

package/types/profile-params.d.ts

@@ -0,0 +1,127 @@
+export type OS = 'lin' | 'mac' | 'win' | 'android';
+export type T_OS_SPEC = 'M1' | 'M2' | 'M3' | 'M3' | 'win11' | '';
+
+export type IBookmarkFoldersObj = {
+  [key: string]: {
+    name: string;
+    children: Array<{
+      name: string;
+      url: string;
+    }>;
+  };
+}
+
+export type NavigatorModel = {
+  userAgent: string;
+  resolution: string;
+  language: string;
+  platform: string;
+  hardwareConcurrency: number;
+  deviceMemory: number;
+  maxTouchPoints?: number;
+}
+
+export type TimezoneModel = {
+  enabled: boolean;
+  fillBasedOnIp: boolean;
+  timezone: string;
+}
+
+export type GeolocationModel = {
+  mode: 'prompt' | 'block' | 'allow';
+  enabled: boolean;
+  customize: boolean;
+  fillBasedOnIp: boolean;
+  latitude: number;
+  longitude: number;
+  accuracy: number;
+}
+
+export type AudioContextModel = {
+  enable: boolean;
+  noiseValue: number;
+}
+
+export type CanvasModel = {
+  mode: 'off' | 'noise';
+  noise?: number;
+}
+
+export type FontsModel = {
+  enableMasking: boolean;
+  enableDOMRect: boolean;
+  families: string[];
+}
+
+export type MediaDevicesModel = {
+  enableMasking: boolean;
+  videoInputs: number;
+  audioInputs: number;
+  audioOutputs: number;
+}
+
+export type WebRTCModel = {
+  mode: 'real' | 'public';
+  enabled: boolean;
+  customize: boolean;
+  localIpMasking: boolean;
+  fillBasedOnIp: boolean;
+  publicIp: string;
+  localIps: string[];
+}
+
+export type WebGlModel = {
+  mode: 'off' | 'noise';
+  getClientRectsNoise: number;
+  noise?: number;
+}
+
+export type ClientRectsModel = {
+  mode: 'off' | 'noise';
+  noise: number;
+}
+
+export type WebGlMetadataModel {
+  mode: 'off' | 'mask';
+  vendor: string;
+  renderer: string;
+}
+
+export type BrowserProxyCreateValidation {
+  mode: 'http' | 'https' | 'socks4' | 'socks5' | 'geolocation' | 'none' | 'tor' | 'gologin';
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+  changeIpUrl?: string;
+  autoProxyRegion?: string;
+  torProxyRegion?: string;
+}
+
+export declare class CreateCustomBrowserValidation {
+  name?: string;
+  notes?: string;
+  autoLang?: boolean;
+  lockEnabled?: boolean;
+  folderName?: string;
+  bookmarks?: IBookmarkFoldersObj;
+  os: OS;
+  osSpec?: T_OS_SPEC;
+  devicePixelRatio?: number;
+  navigator?: NavigatorModel;
+  proxy?: BrowserProxyCreateValidation;
+  dns?: string;
+  timezone?: TimezoneModel;
+  geolocation?: GeolocationModel;
+  audioContext?: AudioContextModel;
+  canvas?: CanvasModel;
+  fonts?: FontsModel;
+  mediaDevices?: MediaDevicesModel;
+  webRTC?: WebRTCModel;
+  webGL?: WebGlModel;
+  clientRects?: ClientRectsModel;
+  webGLMetadata?: WebGlMetadataModel;
+  chromeExtensions?: string[];
+  userChromeExtensions?: string[];
+  folders?: string[];
+}

package/example.js

@@ -1,36 +0,0 @@
-import puppeteer from 'puppeteer-core';
-
-import GoLogin from './src/gologin.js';
-
-const token = 'yU0token';
-const profile_id = 'yU0Pr0f1leiD';
-
-(async () => {
-  const GL = new GoLogin({
-    token,
-    profile_id,
-  });
-
-  const { status, wsUrl } = await GL.start().catch((e) => {
-    console.trace(e);
-
-    return { status: 'failure' };
-  });
-
-  if (status !== 'success') {
-    console.log('Invalid status');
-
-    return;
-  }
-
-  const browser = await puppeteer.connect({
-    browserWSEndpoint: wsUrl.toString(),
-    ignoreHTTPSErrors: true,
-  });
-
-  const page = await browser.newPage();
-  await page.goto('https://myip.link/mini');
-  console.log(await page.content());
-  await browser.close();
-  await GL.stop();
-})();

package/examples/example-amazon-cloud-browser.js

@@ -1,37 +0,0 @@
-// Usage example: in the terminal enter
-// node example-amazon-cloud-browser.js yU0token yU0Pr0f1leiD
-
-// your token api (located in the settings, api)
-// https://github.com/gologinapp/gologin#usage
-
-import GoLogin from 'gologin';
-import puppeteer from 'puppeteer-core';
-
-const [_execPath, _filePath, GOLOGIN_API_TOKEN, GOLOGIN_PROFILE_ID] = process.argv;
-
-(async () => {
-  const GL = new GoLogin({
-    token: GOLOGIN_API_TOKEN,
-    profile_id: GOLOGIN_PROFILE_ID,
-  });
-
-  const browser = await puppeteer.connect({
-    browserWSEndpoint: `https://cloudbrowser.gologin.com/connect?token=${GOLOGIN_API_TOKEN}&profile=${GOLOGIN_PROFILE_ID}`,
-    ignoreHTTPSErrors: true,
-  });
-
-  const page = await browser.newPage();
-
-  await page.goto('https://www.amazon.com/-/dp/B0771V1JZX');
-  const content = await page.content();
-  const matchData = content.match(/'initial': (.*)}/);
-  if (matchData === null || matchData.length === 0){
-    console.log('no images found');
-  } else {
-    const data = JSON.parse(matchData[1]);
-    const images = data.map(e => e.hiRes);
-    console.log('images=', images);
-  }
-
-  await GL.stopRemote();
-})();