gologin 2.1.32 → 2.1.34

package/.eslintrc.json

@@ -4,6 +4,7 @@
     "es2021": true,
     "node": true
   },
+  "parser": "@babel/eslint-parser",
   "extends": "eslint:recommended",
   "overrides": [
     {
@@ -20,8 +21,19 @@
     }
   ],
   "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module"
+    "ecmaVersion": "latest",
+    "sourceType": "module",
+    "requireConfigFile": false,
+    "babelOptions": {
+      "plugins": [
+        [
+          "@babel/plugin-syntax-import-assertions",
+          {
+            "deprecatedAssertSyntax": true
+          }
+        ]
+      ]
+    }
   },
   "plugins": [
     "simple-import-sort"

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Combined changelog for GoLogin node.js SDK
 
+## [2.1.34] 2025-09-11
+
+
+### Fixes
+
+* Errors grouping for internal uses
+
+## [2.1.33] 2025-09-11
+
+
+### Fixes
+
+* Orbita download doesnt interupts while opening two profiles in parallel
+* Error gathering changes
+
 ## [2.1.32] 2025-09-11
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin",
-  "version": "2.1.32",
+  "version": "2.1.34",
   "description": "A high-level API to control Orbita browser over GoLogin API",
   "types": "./index.d.ts",
   "main": "./src/gologin.js",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/gologinapp/gologin.git"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "type": "module",
   "author": "The GoLogin Authors",
@@ -39,6 +39,9 @@
     "example": "examples"
   },
   "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/eslint-parser": "^7.28.5",
+    "@babel/plugin-syntax-import-assertions": "^7.27.1",
     "eslint": "^8.21.0",
     "eslint-plugin-simple-import-sort": "^8.0.0"
   },

package/src/browser/browser-checker.js

@@ -7,9 +7,10 @@ import { homedir } from 'os';
 import { join } from 'path';
 import ProgressBar from 'progress';
 import util from 'util';
-import { createInterface } from 'readline';
 
 import { API_URL, getOS } from '../utils/common.js';
+import { makeRequest } from '../utils/http.js';
+import BrowserDownloadLockManager from './browser-download-manager.js';
 
 const exec = util.promisify(execNonPromise);
 const { access, mkdir, readdir, rmdir, unlink, copyFile, readlink, symlink, lstat, rename, writeFile, readFile } = _promises;
@@ -19,37 +20,31 @@ const ARCH = process.arch;
 
 const VERSION_FILE = 'latest-version.txt';
 
-const WIN_FOLDERSIZE_FILE = 'foldersize.txt';
-const WIN_FOLDERSIZE_FILE_LINK = `https://orbita-browser-windows.gologin.com/${WIN_FOLDERSIZE_FILE}`;
-
 const BROWSER_ARCHIVE_NAME = `orbita-browser-latest.${PLATFORM === 'win32' ? 'zip' : 'tar.gz'}`;
 
 const MAC_HASH_FILE = 'hashfile.mtree';
 const DEB_HASH_FILE = 'hashfile.txt';
-const WIN_HASH_FILE = DEB_HASH_FILE;
 const MAC_HASHFILE_LINK = `https://orbita-browser-mac.gologin.com/${MAC_HASH_FILE}`;
 const DEB_HASHFILE_LINK = `https://orbita-browser-linux.gologin.com/${DEB_HASH_FILE}`;
-const WIN_HASHFILE_LINK = `https://orbita-browser-windows.gologin.com/${WIN_HASH_FILE}`;
 const MAC_ARM_HASHFILE_LINK = `https://orbita-browser-mac-arm.gologin.com/${MAC_HASH_FILE}`;
 
 const FAIL_SUM_MATCH_MESSAGE = 'hash_sum_not_matched';
 const EXTRACTED_FOLDER = 'extracted-browser';
 
 export class BrowserChecker {
-  #homedir = homedir();
-  #browserPath = join(this.#homedir, '.gologin', 'browser');
-  #executableFilePath;
-  #skipOrbitaHashChecking = false;
-
   constructor() {
-
+    this.homedir = homedir();
+    this.browserPath = join(this.homedir, '.gologin', 'browser');
+    this.executableFilePath = null;
+    this.skipOrbitaHashChecking = false;
+    this.downloadManager = BrowserDownloadLockManager.getInstance();
+    this.downloadManager.cleanupStaleLocks().catch(console.warn);
   }
 
-  async checkBrowser({ autoUpdateBrowser, checkBrowserUpdate, majorVersion }) {
-    const isBrowserFolderExists = await access(join(this.#browserPath, `orbita-browser-${majorVersion}`)).then(() => true).catch(() => false);
-
+  async checkBrowser({ autoUpdateBrowser, majorVersion }) {
+    const isBrowserFolderExists = await access(join(this.browserPath, `orbita-browser-${majorVersion}`)).then(() => true).catch(() => false);
     if (!isBrowserFolderExists || autoUpdateBrowser) {
-      await this.downloadBrowser(majorVersion);
+      await this.downloadManager.ensureBrowserDownload(majorVersion, () => this.downloadBrowser(majorVersion));
 
       return this.getBrowserExecutablePath(majorVersion);
     }
@@ -71,8 +66,6 @@ export class BrowserChecker {
     //   return this.getBrowserExecutablePath(majorVersion);
     // }
 
-
-
     // return new Promise(resolve => {
     //   const rl = createInterface(process.stdin, process.stdout);
     //   const timeout = setTimeout(() => {
@@ -94,9 +87,9 @@ export class BrowserChecker {
   }
 
   async downloadBrowser(majorVersion) {
-    await mkdir(this.#browserPath, { recursive: true });
+    await mkdir(this.browserPath, { recursive: true });
 
-    const browserPath = join(this.#browserPath, BROWSER_ARCHIVE_NAME);
+    const browserPath = join(this.browserPath, BROWSER_ARCHIVE_NAME);
 
     const browserDownloadUrl = this.getBrowserDownloadUrl(majorVersion);
 
@@ -110,13 +103,13 @@ export class BrowserChecker {
     const os = getOS();
     switch (os) {
       case 'mac':
-        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
+        return join(this.browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
       case 'win':
-        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'chrome.exe');
+        return join(this.browserPath, `orbita-browser-${majorVersion}`, 'chrome.exe');
       case 'macM1':
-        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
+        return join(this.browserPath, `orbita-browser-${majorVersion}`, 'Orbita-Browser.app', 'Contents', 'MacOS', 'Orbita');
       default:
-        return join(this.#browserPath, `orbita-browser-${majorVersion}`, 'chrome');
+        return join(this.browserPath, `orbita-browser-${majorVersion}`, 'chrome');
     }
   }
 
@@ -129,14 +122,16 @@ export class BrowserChecker {
         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`;
+      case 'linArm':
+        return `https://orbita-browser-linux-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) {
-    return mkdir(join(this.#browserPath, 'orbita-browser', 'version'), { recursive: true })
-      .then(() => writeFile(join(this.#browserPath, 'orbita-browser', 'version', 'latest-version.txt'), latestVersion));
+    return mkdir(join(this.browserPath, 'orbita-browser', 'version'), { recursive: true })
+      .then(() => writeFile(join(this.browserPath, 'orbita-browser', 'version', 'latest-version.txt'), latestVersion));
   }
 
   async downloadBrowserArchive(link, pathStr) {
@@ -155,6 +150,7 @@ export class BrowserChecker {
         const formattedLen = len / 1024 / 1024;
         if (isNaN(formattedLen)) {
           reject(new Error('Error downloading browser'));
+
           return;
         }
 
@@ -204,9 +200,9 @@ export class BrowserChecker {
 
   async extractBrowser() {
     console.log('Extracting Orbita');
-    await mkdir(join(this.#browserPath, EXTRACTED_FOLDER), { recursive: true });
+    await mkdir(join(this.browserPath, EXTRACTED_FOLDER), { recursive: true });
     if (PLATFORM === 'win32') {
-      return decompress(join(this.#browserPath, BROWSER_ARCHIVE_NAME), join(this.#browserPath, EXTRACTED_FOLDER),
+      return decompress(join(this.browserPath, BROWSER_ARCHIVE_NAME), join(this.browserPath, EXTRACTED_FOLDER),
         {
           plugins: [decompressUnzip()],
           filter: file => !file.path.endsWith('/'),
@@ -215,20 +211,20 @@ export class BrowserChecker {
     }
 
     return exec(
-      `tar xzf ${join(this.#browserPath, BROWSER_ARCHIVE_NAME)} --directory ${join(this.#browserPath, EXTRACTED_FOLDER)}`,
+      `tar xzf ${join(this.browserPath, BROWSER_ARCHIVE_NAME)} --directory ${join(this.browserPath, EXTRACTED_FOLDER)}`,
     );
   }
 
   async downloadHashFile(latestVersion) {
     let hashLink = DEB_HASHFILE_LINK;
-    let resultPath = join(this.#browserPath, DEB_HASH_FILE);
+    let resultPath = join(this.browserPath, DEB_HASH_FILE);
     if (PLATFORM === 'darwin') {
       hashLink = MAC_HASHFILE_LINK;
       if (ARCH === 'arm64') {
         hashLink = MAC_ARM_HASHFILE_LINK;
       }
 
-      resultPath = join(this.#browserPath, MAC_HASH_FILE);
+      resultPath = join(this.browserPath, MAC_HASH_FILE);
     }
 
     if (latestVersion) {
@@ -256,13 +252,13 @@ export class BrowserChecker {
       }).on('error', (err) => writableStream.destroy(err)));
 
     const hashFile = PLATFORM === 'darwin' ? MAC_HASH_FILE : DEB_HASH_FILE;
-    const hashFilePath = join(this.#browserPath, hashFile);
+    const hashFilePath = join(this.browserPath, hashFile);
 
     return access(hashFilePath);
   }
 
   async checkBrowserSum(latestVersion) {
-    if (this.#skipOrbitaHashChecking) {
+    if (this.skipOrbitaHashChecking) {
       return Promise.resolve();
     }
 
@@ -274,7 +270,7 @@ export class BrowserChecker {
     await this.downloadHashFile(latestVersion);
     if (PLATFORM === 'darwin') {
       const calculatedHash = await exec(
-        `mtree -p ${join(this.#browserPath, EXTRACTED_FOLDER, 'Orbita-Browser.app')} < ${join(this.#browserPath, MAC_HASH_FILE)} || echo ${FAIL_SUM_MATCH_MESSAGE}`,
+        `mtree -p ${join(this.browserPath, EXTRACTED_FOLDER, 'Orbita-Browser.app')} < ${join(this.browserPath, MAC_HASH_FILE)} || echo ${FAIL_SUM_MATCH_MESSAGE}`,
       );
 
       const checkedRes = (calculatedHash || '').toString().trim();
@@ -285,16 +281,16 @@ export class BrowserChecker {
       return;
     }
 
-    const hashFileContent = await exec(`cat ${join(this.#browserPath, DEB_HASH_FILE)}`);
+    const hashFileContent = await exec(`cat ${join(this.browserPath, DEB_HASH_FILE)}`);
     let serverRes = (hashFileContent.stdout || '').toString().trim();
     serverRes = serverRes.split(' ')[0];
 
     const calculateLocalBrowserHash = await exec(
-      `cd ${join(this.#browserPath, EXTRACTED_FOLDER)} && find orbita-browser -type f -print0 | sort -z | \
-            xargs -0 sha256sum > ${this.#browserPath}/calculatedFolderSha.txt`,
+      `cd ${join(this.browserPath, EXTRACTED_FOLDER)} && find orbita-browser -type f -print0 | sort -z | \
+            xargs -0 sha256sum > ${this.browserPath}/calculatedFolderSha.txt`,
     );
 
-    const localHashContent = await exec(`cd ${this.#browserPath} && sha256sum calculatedFolderSha.txt`);
+    const localHashContent = await exec(`cd ${this.browserPath} && sha256sum calculatedFolderSha.txt`);
     let userRes = (localHashContent.stdout || '').toString().trim();
     userRes = userRes.split(' ')[0];
     if (userRes !== serverRes) {
@@ -304,28 +300,28 @@ export class BrowserChecker {
 
   async replaceBrowser(majorVersion) {
     console.log('Copy Orbita to target path');
-    const targetBrowserPath = join(this.#browserPath, `orbita-browser-${majorVersion}`);
+    const targetBrowserPath = join(this.browserPath, `orbita-browser-${majorVersion}`);
     await this.deleteDir(targetBrowserPath);
 
     if (PLATFORM === 'darwin') {
-      return rename(join(this.#browserPath, EXTRACTED_FOLDER), targetBrowserPath);
+      return rename(join(this.browserPath, EXTRACTED_FOLDER), targetBrowserPath);
     }
 
     await this.copyDir(
-      join(this.#browserPath, EXTRACTED_FOLDER, 'orbita-browser'),
+      join(this.browserPath, EXTRACTED_FOLDER, 'orbita-browser'),
       targetBrowserPath,
     );
   }
 
   async deleteOldArchives() {
-    await this.deleteDir(join(this.#browserPath, EXTRACTED_FOLDER));
+    await this.deleteDir(join(this.browserPath, EXTRACTED_FOLDER));
 
-    return readdir(this.#browserPath)
+    return readdir(this.browserPath)
       .then((files) => {
         const promises = [];
         files.forEach((filename) => {
           if (filename.match(/(txt|dylib|mtree)/)) {
-            promises.push(unlink(join(this.#browserPath, filename)));
+            promises.push(unlink(join(this.browserPath, filename)));
           }
         });
 
@@ -355,38 +351,22 @@ export class BrowserChecker {
   }
 
   async getCurrentVersion(majorVersion) {
-    let versionFilePath = join(this.#browserPath, `orbita-browser-${majorVersion}`, 'version');
+    let versionFilePath = join(this.browserPath, `orbita-browser-${majorVersion}`, 'version');
     if (PLATFORM === 'darwin') {
-      versionFilePath = join(this.#browserPath, `orbita-browser-${majorVersion}`, 'version', VERSION_FILE);
+      versionFilePath = join(this.browserPath, `orbita-browser-${majorVersion}`, 'version', VERSION_FILE);
     }
 
-    return (await readFile(versionFilePath, 'utf8').catch(() => '0.0.0')).replace(/[\r\n\t\f\v\u0000-\u001F\u007F]/g, '');
+    return (await readFile(versionFilePath, 'utf8').catch(() => '0.0.0')).replace(/[\r\n\t\f\v\x00-\x1F\x7F]/g, '');
   }
 
   getLatestBrowserVersion() {
     const userOs = getOS();
 
-    return new Promise(resolve => get(`${API_URL}/gologin-global-settings/latest-browser-info?os=${userOs}`,
-      {
-        timeout: 15 * 1000,
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'gologin-api',
-        },
-      }, (res) => {
-        res.setEncoding('utf8');
-
-        let resultResponse = '';
-        res.on('data', (data) => resultResponse += data);
-
-        res.on('end', () => {
-          resolve(JSON.parse(resultResponse.trim()));
-        });
-      }).on('error', (err) => resolve('')));
+    return makeRequest(`${API_URL}/gologin-global-settings/latest-browser-info?os=${userOs}`);
   }
 
   get getOrbitaPath() {
-    return this.#executableFilePath;
+    return this.executableFilePath;
   }
 
   async deleteDir(path = '') {

package/src/browser/browser-download-manager.js

@@ -0,0 +1,222 @@
+import { spawn } from 'child_process';
+import { promises as _promises } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const { access, writeFile, unlink, mkdir } = _promises;
+
+const HOMEDIR = homedir();
+const BROWSER_PATH = join(HOMEDIR, '.gologin', 'browser');
+const LOCK_FILE_PREFIX = 'download-lock-';
+
+export class BrowserDownloadLockManager {
+  constructor() {
+    if (BrowserDownloadLockManager.instance) {
+      return BrowserDownloadLockManager.instance;
+    }
+
+    BrowserDownloadLockManager.instance = this;
+    BrowserDownloadLockManager.downloadPromises = new Map();
+  }
+
+  static getInstance() {
+    if (!BrowserDownloadLockManager.instance) {
+      BrowserDownloadLockManager.instance = new BrowserDownloadLockManager();
+    }
+
+    return BrowserDownloadLockManager.instance;
+  }
+
+  async ensureBrowserDownload(majorVersion, downloadFunction) {
+    const lockKey = `${majorVersion}`;
+
+    if (BrowserDownloadLockManager.downloadPromises.has(lockKey)) {
+      return BrowserDownloadLockManager.downloadPromises.get(lockKey);
+    }
+
+    const lockFilePath = join(BROWSER_PATH, `${LOCK_FILE_PREFIX}${majorVersion}.json`);
+
+    try {
+      await mkdir(BROWSER_PATH, { recursive: true });
+
+      const isBrowserExists = await this.checkBrowserExists(majorVersion);
+      if (isBrowserExists) {
+        return majorVersion;
+      }
+
+      const lockPromise = this.acquireLockAndDownload(lockFilePath, majorVersion, downloadFunction);
+      BrowserDownloadLockManager.downloadPromises.set(lockKey, lockPromise);
+
+      try {
+        const result = await lockPromise;
+
+        return result;
+      } finally {
+        BrowserDownloadLockManager.downloadPromises.delete(lockKey);
+      }
+    } catch (error) {
+      BrowserDownloadLockManager.downloadPromises.delete(lockKey);
+      throw error;
+    }
+  }
+
+  async acquireLockAndDownload(lockFilePath, majorVersion, downloadFunction) {
+    const maxWaitTime = 300000;
+    const checkInterval = 1000;
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < maxWaitTime) {
+      try {
+        await this.createLockFile(lockFilePath, majorVersion);
+
+        const isBrowserExists = await this.checkBrowserExists(majorVersion);
+        if (isBrowserExists) {
+          await this.releaseLock(lockFilePath);
+
+          return majorVersion;
+        }
+
+        await downloadFunction();
+        await this.releaseLock(lockFilePath);
+
+        return majorVersion;
+      } catch (error) {
+        if (error.code === 'EEXIST') {
+          const lockValid = await this.checkLockValidity(lockFilePath);
+          if (!lockValid) {
+            console.log(`Lock file ${lockFilePath} is stale, removing it`);
+            await this.releaseLock(lockFilePath);
+            continue;
+          }
+
+          await this.waitForLockRelease(lockFilePath, checkInterval);
+          continue;
+        }
+
+        await this.releaseLock(lockFilePath);
+        throw error;
+      }
+    }
+
+    throw new Error(`Timeout waiting for browser download lock for version ${majorVersion}`);
+  }
+
+  async createLockFile(lockFilePath, majorVersion) {
+    const lockData = {
+      majorVersion,
+      timestamp: Date.now(),
+      pid: process.pid,
+    };
+
+    await writeFile(lockFilePath, JSON.stringify(lockData), { flag: 'wx' });
+  }
+
+  async releaseLock(lockFilePath) {
+    try {
+      await unlink(lockFilePath);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('Failed to release download lock:', error.message);
+      }
+    }
+  }
+
+  async waitForLockRelease(lockFilePath, checkInterval) {
+    return new Promise((resolve) => {
+      const checkLock = async () => {
+        try {
+          await access(lockFilePath);
+          setTimeout(checkLock, checkInterval);
+        } catch (error) {
+          if (error.code === 'ENOENT') {
+            resolve();
+          } else {
+            setTimeout(checkLock, checkInterval);
+          }
+        }
+      };
+
+      checkLock();
+    });
+  }
+
+  async checkBrowserExists(majorVersion) {
+    try {
+      await access(join(BROWSER_PATH, `orbita-browser-${majorVersion}`));
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async isProcessRunning(pid) {
+    return new Promise((resolve) => {
+      const { platform } = process;
+      let command;
+      let args;
+
+      if (platform === 'win32') {
+        command = 'tasklist';
+        args = ['/FI', `PID eq ${pid}`];
+      } else {
+        command = 'ps';
+        args = ['-p', pid.toString()];
+      }
+
+      const child = spawn(command, args, { stdio: 'pipe' });
+
+      child.on('error', () => resolve(false));
+      child.on('close', (code) => {
+        resolve(code === 0);
+      });
+    });
+  }
+
+  async checkLockValidity(lockFilePath) {
+    try {
+      const lockContent = await _promises.readFile(lockFilePath, 'utf8');
+      const lockData = JSON.parse(lockContent);
+
+      const lockAge = Date.now() - lockData.timestamp;
+      const maxLockAge = 300000;
+
+      if (lockAge > maxLockAge) {
+        return false;
+      }
+
+      const isProcessAlive = await this.isProcessRunning(lockData.pid);
+
+      return isProcessAlive;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async cleanupStaleLocks() {
+    try {
+      const files = await _promises.readdir(BROWSER_PATH);
+      const lockFiles = files.filter(file => file.startsWith(LOCK_FILE_PREFIX));
+
+      for (const lockFile of lockFiles) {
+        try {
+          const lockFilePath = join(BROWSER_PATH, lockFile);
+          const isValid = await this.checkLockValidity(lockFilePath);
+
+          if (!isValid) {
+            await unlink(lockFilePath);
+            console.log(`Cleaned up stale lock file: ${lockFile}`);
+          }
+        } catch (error) {
+          console.warn(`Failed to process lock file ${lockFile}:`, error.message);
+        }
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('Failed to cleanup stale locks:', error.message);
+      }
+    }
+  }
+}
+
+export default BrowserDownloadLockManager;

package/src/gologin.js

@@ -5,10 +5,9 @@ import decompress from 'decompress';
 import decompressUnzip from 'decompress-unzip';
 import { existsSync, mkdirSync, promises as _promises } from 'fs';
 import { tmpdir } from 'os';
-import { dirname, join, resolve as _resolve, sep } from 'path';
+import { join, resolve as _resolve, sep } from 'path';
 import rimraf from 'rimraf';
 import { SocksProxyAgent } from 'socks-proxy-agent';
-import { fileURLToPath } from 'url';
 
 import { fontsCollection } from '../fonts.js';
 import { getCurrentProfileBookmarks } from './bookmarks/utils.js';
@@ -33,8 +32,10 @@ import { STORAGE_GATEWAY_BASE_URL } from './utils/constants.js';
 import { get, isPortReachable } from './utils/utils.js';
 export { exitAll, GologinApi } from './gologin-api.js';
 import { checkSocksProxy, makeRequest } from './utils/http.js';
+import { captureGroupedSentryError } from './utils/sentry.js';
 import { zeroProfileBookmarks } from './utils/zero-profile-bookmarks.js';
 import { zeroProfilePreferences } from './utils/zero-profile-preferences.js';
+
 const { access, unlink, writeFile, readFile, mkdir, copyFile } = _promises;
 
 const SEPARATOR = sep;
@@ -89,7 +90,7 @@ export class GoLogin {
         dsn: 'https://a13d5939a60ae4f6583e228597f1f2a0@sentry-new.amzn.pro/24',
         tracesSampleRate: 1.0,
         defaultIntegrations: false,
-        release: process.env.npm_package_version || '2.1.24',
+        release: process.env.npm_package_version || '2.1.34',
       });
     }
 
@@ -213,16 +214,6 @@ export class GoLogin {
     console.log('Profile has been uploaded to S3 successfully');
   }
 
-  async emptyProfileFolder() {
-    debug('get emptyProfileFolder');
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    const zeroProfilePath = join(currentDir, '..', 'zero_profile.zip');
-    const profile = await readFile(_resolve(zeroProfilePath));
-    debug('emptyProfileFolder LENGTH ::', profile.length);
-
-    return profile;
-  }
-
   getGologinPreferences(profileData) {
     const os = profileData.os || '';
     const osSpec = profileData.osSpec || '';
@@ -417,9 +408,7 @@ export class GoLogin {
       debug('extraction done');
     } catch (e) {
       console.trace(e);
-      profile_folder = await this.emptyProfileFolder();
-      await writeFile(this.profile_zip_path, profile_folder);
-      await this.extractProfile(profilePath, this.profile_zip_path);
+      await this.createZeroProfile(this.createCookiesTableQuery);
     }
 
     const singletonLockPath = join(profilePath, 'SingletonLock');
@@ -1094,6 +1083,7 @@ export class GoLogin {
       debug('browser killed');
     } catch (error) {
       console.error(error);
+      captureGroupedSentryError(error, { method: 'killBrowser', profileId: this.profile_id });
     }
   }
 
@@ -1187,13 +1177,6 @@ export class GoLogin {
     const fingerprint = await this.getRandomFingerprint(options);
     debug('fingerprint=', fingerprint);
 
-    if (fingerprint.statusCode === 500) {
-      throw new Error('no valid random fingerprint check os param');
-    }
-
-    if (fingerprint.statusCode === 401) {
-      throw new Error('invalid token');
-    }
 
     const { navigator, fonts, webGLMetadata, webRTC } = fingerprint;
     let deviceMemory = navigator.deviceMemory || 2;
@@ -1371,18 +1354,20 @@ export class GoLogin {
       }
     } catch (error) {
       if (!isSecondTry && (error.message.includes('table cookies has no column') || error.message.includes('NOT NULL constraint failed'))) {
-        await _promises.rm(cookiesPaths.primary, { recursive: true, force: true });
+        await db.close();
+        await _promises.rm(cookiesPaths.primary, { recursive: true, force: true }).catch(() => null);
         await createDBFile({
           cookiesFilePath: cookiesPaths.primary,
           cookiesFileSecondPath: cookiesPaths.secondary,
           createCookiesTableQuery: this.createCookiesTableQuery,
-        });
-        await this.writeCookiesToFile(cookies, true);
+        }).catch(console.error);
+        await this.writeCookiesToFile(cookies, true).catch(console.error);
 
         return;
       }
 
       console.error(error.message);
+      captureGroupedSentryError(error, { method: 'writeCookiesToFile', profileId: this.profile_id });
     } finally {
       db && await db.close();
       await ensureDirectoryExists(cookiesPaths.primary);
@@ -1407,7 +1392,7 @@ export class GoLogin {
 
       return { status: 'success', wsUrl: startResponse.wsUrl, resolution: startResponse.resolution };
     } catch (error) {
-      Sentry.captureException(error);
+      captureGroupedSentryError(error, { method: 'start', profileId: this.profile_id });
       throw error;
     }
   }
@@ -1514,10 +1499,6 @@ export class GoLogin {
       method: 'GET',
     }, { token: this.access_token, fallbackUrl: `${FALLBACK_API_URL}/browser/v2` });
 
-    if (profilesResponse.statusCode !== 200) {
-      throw new Error('Gologin /browser response error');
-    }
-
     return JSON.parse(profilesResponse);
   }
 

package/src/utils/common.js

@@ -14,6 +14,8 @@ const CHROME_EXT_DIR_NAME = 'chrome-extensions';
 const EXTENSIONS_PATH = join(HOMEDIR, '.gologin', 'extensions');
 const CHROME_EXTENSIONS_PATH = join(EXTENSIONS_PATH, CHROME_EXT_DIR_NAME);
 const USER_EXTENSIONS_PATH = join(HOMEDIR, '.gologin', 'extensions', 'user-extensions');
+const PLATFORM = process.platform;
+const ARCH = process.arch;
 
 const composeExtractionPromises = (filteredArchives, destPath = CHROME_EXTENSIONS_PATH) => (
   filteredArchives.map((extArchivePath) => {
@@ -64,15 +66,15 @@ const getOsAdvanced = async () => {
 };
 
 const getOS = () => {
-  if (process.platform === 'win32') {
+  if (PLATFORM === 'win32') {
     return 'win';
   }
 
-  if (process.platform === 'darwin') {
-    return process.arch === 'arm64' ? 'macM1' : 'mac';
+  if (PLATFORM === 'darwin') {
+    return ARCH === 'arm64' ? 'macM1' : 'mac';
   }
 
-  return 'lin';
+  return ARCH === 'arm64' ? 'linArm' : 'lin';
 };
 
 const _composeExtractionPromises = composeExtractionPromises;

package/src/utils/http.js

@@ -1,6 +1,10 @@
 import { get as _get } from 'https';
 import requests from 'requestretry';
 
+import packageJson from '../../package.json' assert { type: 'json' };
+
+const { version } = packageJson;
+
 const TIMEZONE_URL = 'https://geo.myip.link';
 
 const createTimeoutPromise = (timeoutMs) => new Promise((_, reject) => {
@@ -32,7 +36,7 @@ const attemptRequest = async (requestUrl, options) => {
 export const makeRequest = async (url, options, internalOptions) => {
   options.headers = {
     ...options.headers,
-    'User-Agent': 'gologin-nodejs-sdk',
+    'User-Agent': `gologin-nodejs-sdk/${version}`,
   };
 
   if (internalOptions?.token) {
@@ -46,7 +50,9 @@ export const makeRequest = async (url, options, internalOptions) => {
     return await attemptRequest(url, options);
   } catch (error) {
     if (internalOptions?.fallbackUrl && !error.statusCode) {
-      return attemptRequest(internalOptions.fallbackUrl, options);
+      const fallbackData = await attemptRequest(internalOptions.fallbackUrl, options);
+
+      return fallbackData;
     }
 
     throw error;

package/src/utils/sentry.js

@@ -0,0 +1,73 @@
+import * as Sentry from '@sentry/node';
+
+export const captureGroupedSentryError = (error, context = {}) => {
+  if (process.env.DISABLE_TELEMETRY === 'true') {
+    return;
+  }
+
+  const errorMessage = error?.message || 'Unknown error';
+  let fingerprint = ['default'];
+  let tags = { errorType: 'unknown' };
+
+  switch (true) {
+    case errorMessage.includes('Profile deleted or not found'):
+      fingerprint = ['profile-not-found'];
+      tags = { errorType: 'profile', category: 'configuration' };
+      break;
+
+    case errorMessage.includes('Request timeout after 13000ms'):
+    case errorMessage.includes('Proxy Error'):
+      fingerprint = ['proxy-error'];
+      tags = { errorType: 'proxy', category: 'configuration' };
+      break;
+
+    case errorMessage.includes('ENOSPC'):
+    case errorMessage.includes('database or disk is full'):
+      fingerprint = ['out-of-space'];
+      tags = { errorType: 'out-of-space', category: 'filesystem' };
+      break;
+
+    case errorMessage.includes('ECONNREFUSED 127.0.0.1:'):
+      fingerprint = ['browser-not-found'];
+      tags = { errorType: 'browser', category: 'configuration' };
+      break;
+
+    case errorMessage.includes('end of central directory record signature not found'):
+    case errorMessage.includes('invalid code lengths set'):
+    case errorMessage.includes('Command failed: tar xzf'):
+      fingerprint = ['archive-error'];
+      tags = { errorType: 'archive', category: 'binaries' };
+      break;
+
+    case errorMessage.includes('spawn UNKNOWN'):
+      fingerprint = ['spawn-error'];
+      tags = { errorType: 'spawn', category: 'runtime' };
+      break;
+
+    case errorMessage.includes('unable to verify the first certificate'):
+    case errorMessage.includes('write EPROTO'):
+      fingerprint = ['ssl-error'];
+      tags = { errorType: 'ssl', category: 'network' };
+      break;
+
+    case errorMessage.includes('You have reached your free API requests limit'):
+      fingerprint = ['api-limit-reached'];
+      tags = { errorType: 'api', category: 'rate-limit' };
+      break;
+
+    default:
+      fingerprint = ['uncategorized', errorMessage.substring(0, 50)];
+      tags = { errorType: 'uncategorized', category: 'unknown' };
+      break;
+  }
+
+  Sentry.captureException(error, scope => {
+    scope.setFingerprint(fingerprint);
+    scope.setTransactionName(fingerprint);
+    scope.setTags(tags);
+    scope.setContext('errorDetails', {
+      originalMessage: errorMessage,
+      ...context,
+    });
+  });
+};