gologin 2.1.32 → 2.1.33

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Combined changelog for GoLogin node.js SDK
 
+## [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.33",
   "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

@@ -7,9 +7,9 @@ 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 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 +19,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 +65,6 @@ export class BrowserChecker {
     //   return this.getBrowserExecutablePath(majorVersion);
     // }
 
-
-
     // return new Promise(resolve => {
     //   const rl = createInterface(process.stdin, process.stdout);
     //   const timeout = setTimeout(() => {
@@ -94,9 +86,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 +102,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');
     }
   }
 
@@ -135,8 +127,8 @@ export class BrowserChecker {
   }
 
   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 +147,7 @@ export class BrowserChecker {
         const formattedLen = len / 1024 / 1024;
         if (isNaN(formattedLen)) {
           reject(new Error('Error downloading browser'));
+
           return;
         }
 
@@ -204,9 +197,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 +208,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 +249,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 +267,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 +278,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 +297,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,12 +348,12 @@ 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() {
@@ -386,7 +379,7 @@ export class BrowserChecker {
   }
 
   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.33',
       });
     }
 
@@ -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 });
     }
   }
 
@@ -1371,18 +1361,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 +1399,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;
     }
   }

package/src/utils/http.js

@@ -46,7 +46,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.withScope((scope) => {
+    scope.setFingerprint(fingerprint);
+    scope.setTags(tags);
+    scope.setContext('errorDetails', {
+      originalMessage: errorMessage,
+      ...context,
+    });
+    Sentry.captureException(error);
+  });
+};