gologin 3.0.2 → 3.0.4

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 Combined changelog for GoLogin node.js SDK
 
+## [3.0.4] 2026-09-04
+
+### Fixes
+
+* Fixed proxy request timeout not aborting hung TCP connects during timezone checks
+* Reduced default proxy check timeout to 10s and attempts to 2
+
+## [3.0.3] 2026-08-03
+
+### Fixes
+
+* Fixed Chrome extensions download race when the same extension IDs are listed in both `chromeExtensions` and `userChromeExtensions`
+* Made extension archive deletion ignore missing files (`ENOENT`) during parallel extract cleanup
+
+### Features
+
+* Added profile start step timings via `debug` (`DEBUG=gologin`)
+
 ## [3.0.2] 2026-07-29
 
 ### Features

package/package.json

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

package/src/extensions/extensions-extractor.js

@@ -29,11 +29,13 @@ export const deleteExtensionArchive = (dest) => {
     throw new Error('Missing parameter');
   }
 
-  return access(dest)
-    .then(
-      () => unlink(dest),
-      () => Promise.resolve(),
-    );
+  return unlink(dest).catch((error) => {
+    if (error?.code === 'ENOENT') {
+      return;
+    }
+
+    throw error;
+  });
 };
 
 const withRetry = optionsOrUndefined => {

package/src/extensions/extensions-manager.js

@@ -107,11 +107,13 @@ export class ExtensionsManager extends UserExtensionsManager {
 
       return originalId;
     });
+    const queuedOriginalIds = new Set();
 
     return profileExtensions.reduce((res, val) => {
       const [originalId] = val.split('@');
-      const extensionExists = existedOriginalIds.includes(originalId);
+      const extensionExists = existedOriginalIds.includes(originalId) || queuedOriginalIds.has(originalId);
       if (!extensionExists) {
+        queuedOriginalIds.add(originalId);
         res.push(val);
       }
 

package/src/gologin.js

@@ -40,6 +40,15 @@ const PROXY_NONE = 'none';
 const debug = debugDefault('gologin');
 const delay = (time) => new Promise((resolve) => setTimeout(resolve, time));
 
+const withTiming = async ({ name, promise }) => {
+  const start = Date.now();
+  try {
+    return await promise;
+  } finally {
+    debug(`[timing] ${name}: ${Date.now() - start}ms`);
+  }
+};
+
 export class GoLogin {
   constructor(options = {}) {
     this.browserLang = 'en-US';
@@ -76,8 +85,8 @@ export class GoLogin {
     this.processKillTimeout = 1 * 1000;
     this.browserMajorVersion = options.browserMajorVersion || 0;
     this.newProxyOrbitaMajorVersion = 135;
-    this.proxyCheckTimeout = options.proxyCheckTimeout || 13 * 1000;
-    this.proxyCheckAttempts = options.proxyCheckAttempts || 3;
+    this.proxyCheckTimeout = options.proxyCheckTimeout || 10 * 1000;
+    this.proxyCheckAttempts = options.proxyCheckAttempts || 2;
     this.customChromeFrame = options.customChromeFrame;
 
     if (options.tmpdir) {
@@ -463,13 +472,17 @@ export class GoLogin {
   }
 
   async createStartup(local = false) {
+    const startupStart = Date.now();
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
     const startupDepsPromise = preloadStartupDeps();
 
     const [profile] = await Promise.all([
-      this.getProfile(),
-      startupDepsPromise.then(() => removePath(profilePath)
-        .then(() => debug('-', profilePath, 'dropped'))),
+      withTiming({ name: 'getProfile', promise: this.getProfile() }),
+      withTiming({
+        name: 'preloadDepsAndClearProfile',
+        promise: startupDepsPromise.then(() => removePath(profilePath)
+          .then(() => debug('-', profilePath, 'dropped'))),
+      }),
     ]);
 
     if (!profile) {
@@ -525,37 +538,55 @@ export class GoLogin {
     this.proxy = proxy;
 
     await Promise.all([
-      this.resolveProfileBrowserVersion(profile),
-      this.initProfileStorage({ profile, local }),
-      this.getTimeZone(proxy).catch((e) => {
-        console.error('Proxy Error. Check it and try again.');
-        throw new Error(`Proxy Error. ${e.message}`);
+      withTiming({ name: 'resolveProfileBrowserVersion', promise: this.resolveProfileBrowserVersion(profile) }),
+      withTiming({ name: 'initProfileStorage', promise: this.initProfileStorage({ profile, local }) }),
+      withTiming({
+        name: 'getTimeZone',
+        promise: this.getTimeZone(proxy).catch((e) => {
+          console.error('Proxy Error. Check it and try again.');
+          throw new Error(`Proxy Error. ${e.message}`);
+        }),
       }),
-      this.initCookiesFile(profile),
+      withTiming({ name: 'initCookiesFile', promise: this.initCookiesFile(profile) }),
     ]);
 
-    await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
-    const pref_file_name = join(profilePath, 'Default', 'Preferences');
-    debug('reading', pref_file_name);
+    await withTiming({
+      name: 'preparePreferencesFile',
+      promise: (async () => {
+        await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
+        const pref_file_name = join(profilePath, 'Default', 'Preferences');
+        debug('reading', pref_file_name);
+
+        const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
+        if (!prefFileExists) {
+          debug('Preferences file not exists waiting', pref_file_name, '. Using empty profile');
+          await mkdir(join(profilePath, 'Default'), { recursive: true });
+          await writeFile(pref_file_name, '{}');
+        }
+      })(),
+    });
 
-    const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
-    if (!prefFileExists) {
-      debug('Preferences file not exists waiting', pref_file_name, '. Using empty profile');
-      await mkdir(join(profilePath, 'Default'), { recursive: true });
-      await writeFile(pref_file_name, '{}');
-    }
+    const preferences_raw = await withTiming({
+      name: 'readPreferences',
+      promise: readFile(join(profilePath, 'Default', 'Preferences')),
+    });
 
-    const preferences_raw = await readFile(pref_file_name);
     const preferences = JSON.parse(preferences_raw.toString());
     const chromeExtensions = get(profile, 'chromeExtensions') || [];
     const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
-    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
+    const allExtensions = [...new Set([...chromeExtensions, ...userChromeExtensions])];
 
     const [, orbitaParamsToken] = await Promise.all([
-      this.setupProfileExtensions({
-        preferences, allExtensions, userChromeExtensions, profilePath,
+      withTiming({
+        name: 'setupProfileExtensions',
+        promise: this.setupProfileExtensions({
+          preferences,
+          allExtensions,
+          userChromeExtensions: [...new Set(userChromeExtensions)],
+          profilePath,
+        }),
       }),
-      this.fetchOrbitaParamsToken(profile),
+      withTiming({ name: 'fetchOrbitaParamsToken', promise: this.fetchOrbitaParamsToken(profile) }),
     ]);
 
     if (this.fontsMasking) {
@@ -606,14 +637,21 @@ export class GoLogin {
       },
     };
 
-    await writeFile(join(profilePath, 'orbita.config'), JSON.stringify(orbitaConfig, null, '\t'), { encoding: 'utf-8' }).catch(console.log);
-    await writeFile(join(profilePath, 'Default', 'Preferences'), JSON.stringify(prefsToWrite));
+    await withTiming({
+      name: 'writeProfileFiles',
+      promise: (async () => {
+        await writeFile(join(profilePath, 'orbita.config'), JSON.stringify(orbitaConfig, null, '\t'), { encoding: 'utf-8' }).catch(console.log);
+        await writeFile(join(profilePath, 'Default', 'Preferences'), JSON.stringify(prefsToWrite));
+
+        const bookmarksParsedData = await getCurrentProfileBookmarks(this.bookmarksFilePath);
+        const bookmarksFromDb = profile.bookmarks?.bookmark_bar;
+        bookmarksParsedData.roots = bookmarksFromDb ? profile.bookmarks : bookmarksParsedData.roots;
+        await writeFile(this.bookmarksFilePath, JSON.stringify(bookmarksParsedData));
+      })(),
+    });
 
-    const bookmarksParsedData = await getCurrentProfileBookmarks(this.bookmarksFilePath);
-    const bookmarksFromDb = profile.bookmarks?.bookmark_bar;
-    bookmarksParsedData.roots = bookmarksFromDb ? profile.bookmarks : bookmarksParsedData.roots;
-    await writeFile(this.bookmarksFilePath, JSON.stringify(bookmarksParsedData));
     debug('Profile ready. Path: ', profilePath, 'PROXY', JSON.stringify(get(preferences, 'gologin.proxy')));
+    debug(`[timing] createStartup total: ${Date.now() - startupStart}ms`);
 
     return profilePath;
   }
@@ -723,8 +761,9 @@ export class GoLogin {
 
       const profileExtensionPathRes = extensionsResult.find(el => 'profileExtensionsCheckRes' in el) || {};
       const profileUserExtensionPathRes = extensionsResult.find(el => 'profileUserExtensionsCheckRes' in el);
-      profileExtensionsCheckRes =
-        (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []);
+      profileExtensionsCheckRes = [...new Set(
+        (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []),
+      )];
     }
 
     let extSettings;
@@ -978,9 +1017,13 @@ export class GoLogin {
   }
 
   async spawnBrowser() {
+    const spawnStart = Date.now();
     let { remote_debugging_port, customArgs } = this;
     if (!remote_debugging_port) {
-      remote_debugging_port = await this.getRandomPort();
+      remote_debugging_port = await withTiming({
+        name: 'getRandomPort',
+        promise: this.getRandomPort(),
+      });
     }
 
     const profile_path = this.profilePath();
@@ -996,7 +1039,11 @@ export class GoLogin {
 
     let ORBITA_BROWSER = this.executablePath;
     if (!ORBITA_BROWSER) {
-      const browserChecker = await this.getBrowserChecker();
+      const browserChecker = await withTiming({
+        name: 'getBrowserChecker',
+        promise: this.getBrowserChecker(),
+      });
+
       ORBITA_BROWSER = browserChecker.getOrbitaPath;
     }
 
@@ -1007,9 +1054,12 @@ export class GoLogin {
       env[key] = process.env[key];
     });
 
-    const tz = await this.getTimeZone(this.proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
-      throw e;
+    const tz = await withTiming({
+      name: 'getTimeZone',
+      promise: this.getTimeZone(this.proxy).catch((e) => {
+        console.error('Proxy Error. Check it and try again.');
+        throw e;
+      }),
     });
 
     env.TZ = tz;
@@ -1090,17 +1140,23 @@ export class GoLogin {
 
     if (this.waitWebsocket) {
       debug('GETTING WS URL FROM BROWSER');
-      const data = await makeRequest(
-        `http://127.0.0.1:${remote_debugging_port}/json/version`,
-        { json: true, maxAttempts: 60, retryDelay: 100, method: 'GET' },
-      );
+      const data = await withTiming({
+        name: 'waitWebsocket',
+        promise: makeRequest(
+          `http://127.0.0.1:${remote_debugging_port}/json/version`,
+          { json: true, maxAttempts: 120, retryDelay: 100, method: 'GET' },
+        ),
+      });
 
       debug('WS IS', get(data, 'webSocketDebuggerUrl', ''));
       this.is_active = true;
+      debug(`[timing] spawnBrowser total: ${Date.now() - spawnStart}ms`);
 
       return { wsUrl: get(data, 'webSocketDebuggerUrl', ''), resolution: this.resolution };
     }
 
+    debug(`[timing] spawnBrowser total: ${Date.now() - spawnStart}ms`);
+
     return '';
   }
 
@@ -1508,10 +1564,12 @@ export class GoLogin {
 
   async start() {
     // ensureSentryInitialized({ release: process.env.npm_package_version || '2.1.34' });
+    const startTotal = Date.now();
 
-    await this.createStartup();
-    const startResponse = await this.spawnBrowser();
+    await withTiming({ name: 'createStartup', promise: this.createStartup() });
+    const startResponse = await withTiming({ name: 'spawnBrowser', promise: this.spawnBrowser() });
     this.setActive(true);
+    debug(`[timing] start total: ${Date.now() - startTotal}ms`);
 
     return {
       status: 'success',
@@ -1521,11 +1579,14 @@ export class GoLogin {
   }
 
   async startLocal() {
-    await this.createStartup(true);
+    const startTotal = Date.now();
+
+    await withTiming({ name: 'createStartup', promise: this.createStartup(true) });
 
     // await this.createBrowserExtension();
-    const startResponse = await this.spawnBrowser();
+    const startResponse = await withTiming({ name: 'spawnBrowser', promise: this.spawnBrowser() });
     this.setActive(true);
+    debug(`[timing] startLocal total: ${Date.now() - startTotal}ms`);
 
     return { status: 'success', wsUrl: startResponse.wsUrl };
   }

package/src/utils/http.js

@@ -1,5 +1,5 @@
-import { get as _get, request as httpsRequest } from 'https';
 import { request as httpRequest } from 'http';
+import { get as _get, request as httpsRequest } from 'https';
 
 import packageJson from '../../package.json' with { type: 'json' };
 import { loadHttpsProxyAgent } from './lazy-deps.js';
@@ -115,9 +115,11 @@ const normalizeProxyUrl = (proxyUrl) => {
 };
 
 const executeProxyRequest = async (url, options, internalOptions) => {
-  const HttpsProxyAgent = await loadHttpsProxyAgent();
-  const agent = new HttpsProxyAgent(normalizeProxyUrl(options.proxy));
   const timeoutMs = options.timeout || DEFAULT_TIMEOUT_MS;
+  const HttpsProxyAgent = await loadHttpsProxyAgent();
+  const agent = new HttpsProxyAgent(normalizeProxyUrl(options.proxy), {
+    timeout: timeoutMs,
+  });
   const headers = buildRequestHeaders({ options, internalOptions });
   const body = buildRequestBody(options);
   const method = options.method || 'GET';
@@ -139,6 +141,19 @@ const executeProxyRequest = async (url, options, internalOptions) => {
   };
 
   return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId;
+
+    const settle = (handler) => (value) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      clearTimeout(timeoutId);
+      handler(value);
+    };
+
     const req = requestFn(requestOptions, (response) => {
       let responseText = '';
 
@@ -151,18 +166,28 @@ const executeProxyRequest = async (url, options, internalOptions) => {
           const error = new Error(responseText);
           error.statusCode = response.statusCode;
 
-          reject(error);
+          settle(reject)(error);
 
           return;
         }
 
-        resolve(parseProxyResponseBody(responseText, options));
+        settle(resolve)(parseProxyResponseBody(responseText, options));
       });
+
+      response.on('error', settle(reject));
     });
 
-    req.on('error', reject);
+    timeoutId = setTimeout(() => {
+      const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
+      settle(reject)(timeoutError);
+      req.destroy(timeoutError);
+    }, timeoutMs);
+
+    req.on('error', settle(reject));
     req.on('timeout', () => {
-      req.destroy(new Error(`Request timeout after ${timeoutMs}ms`));
+      const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
+      settle(reject)(timeoutError);
+      req.destroy(timeoutError);
     });
 
     if (body) {
@@ -242,6 +267,7 @@ export const makeRequest = async (url, options = {}, internalOptions) => {
   try {
     return await executeFetch(url, options, internalOptions);
   } catch (error) {
+    console.log('makeRequest error', error);
     if (internalOptions?.fallbackUrl && !error.statusCode) {
       return executeFetch(internalOptions.fallbackUrl, options, internalOptions);
     }