steamutils 1.4.63 → 1.4.64

package/SteamClient.js

@@ -90,11 +90,11 @@ export const SteamClientEvents = {
   accountLimitations: "accountLimitations",
   wallet: "wallet",
   licenses: "licenses",
+  logOff: "logOff",
 };
-const PersonasCache = [];
 let isSendingFriendMessages = false;
 
-function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestFreeLicense = true, isFakeGameScore = true, isPartyRegister = true, isAutoPlay = false, isInvisible = false, autoAcceptTradeRequest = false, autoReconnect = true, MAX_GAME_PLAY = 10, games = null }) {
+function SteamClient({ username, cookie, clientJsToken, isAutoRequestFreeLicense = true, isFakeGameScore = true, isPartyRegister = true, isAutoPlay = false, isInvisible = false, autoAcceptTradeRequest = false, autoReconnect = true, MAX_GAME_PLAY = 10, games = null }) {
   const steamClient = new NodeSteamUser();
   let prime = null;
   let state = "Offline"; //InGame, Online, Invisible
@@ -104,7 +104,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   let lastTimePartyRegister = 0;
   let lastTimePartySearch = 0;
   const ownedApps = [];
-  let logOffEvent = null;
+  const logOffEvents = {};
   let _cleanNodeSteamUserTimeout = null;
   let _cleanNodeSteamLicensesTimeout = null;
   let _cleanNodeSteamFriendTimeout = null;
@@ -124,34 +124,115 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     events[name] = [];
   }
 
-  const gcCallback = {};
+  const gcEvents = {
+    requestJoinFriendData: [],
+    requestCoPlays: [],
+    partySearch: [],
+    playersProfile: [],
+  };
 
-  function pushGCCallback(name, cb, timeout) {
-    if (!gcCallback[name]) {
-      gcCallback[name] = {};
+  function onGCEvent({ name, id, key, callback, timeoutMs }) {
+    if (typeof name !== "string") {
+      name = Object.keys(gcEvents).find((k) => gcEvents[k] === name);
     }
-    let t = null;
-    let id = uuidv4();
 
-    function callback(...arg) {
-      if (t) {
-        clearTimeout(t);
-      }
-      delete gcCallback[name][id];
-      cb?.apply(null, arg);
+    if (!gcEvents[name]) {
+      gcEvents[name] = [];
     }
+    if (!id) {
+      id = uuidv4();
+    }
+    const timeout = timeoutMs
+      ? setTimeout(function () {
+          callback?.();
+          clearGCCallback(id);
+        }, timeoutMs)
+      : null;
+
+    gcEvents[name].push({
+      id,
+      key,
+      timeout,
+      callback,
+    });
+    return id;
+  }
 
-    if (timeout) {
-      t = setTimeout(callback, timeout);
+  function clearGCCallback(name) {
+    if (!Array.isArray(name)) {
+      name = [name];
+    }
+    for (const nameE of name) {
+      switch (typeof nameE) {
+        case "string":
+          if (Array.isArray(gcEvents[nameE])) {
+            //name
+            for (const eventElement of gcEvents[nameE]) {
+              if (eventElement.timeout) {
+                clearTimeout(eventElement.timeout);
+              }
+            }
+            gcEvents[nameE] = [];
+          } else {
+            //id
+            for (const eventsKey in gcEvents) {
+              if (!Array.isArray(gcEvents[eventsKey])) {
+                continue;
+              }
+              const index = gcEvents[eventsKey].findIndex((e) => e.id === nameE);
+              if (index > -1) {
+                if (gcEvents[eventsKey].timeout) {
+                  clearTimeout(gcEvents[eventsKey].timeout);
+                }
+                gcEvents[eventsKey].splice(index, 1);
+              }
+            }
+          }
+          break;
+        case "function":
+          //callback
+          for (const eventsKey in gcEvents) {
+            if (!Array.isArray(gcEvents[eventsKey])) {
+              continue;
+            }
+            const index = gcEvents[eventsKey].findIndex((e) => e.callback === nameE);
+            if (index > -1) {
+              if (gcEvents[eventsKey].timeout) {
+                clearTimeout(gcEvents[eventsKey].timeout);
+              }
+              gcEvents[eventsKey].splice(index, 1);
+            }
+          }
+          break;
+      }
     }
-    gcCallback[name][id] = callback;
   }
 
-  function callGCCallback(name, ...arg) {
-    if (gcCallback[name]) {
-      for (const id in gcCallback[name]) {
-        gcCallback[name][id]?.(...arg);
+  async function callGCCallback({ name, data, key }) {
+    if (typeof name !== "string") {
+      name = Object.keys(gcEvents).find((k) => gcEvents[k] === name);
+    }
+
+    if (!Array.isArray(gcEvents[name])) {
+      return;
+    }
+
+    const events = _.remove(gcEvents[name], (item) => !key || item.key === key);
+    let _data = null;
+    let calculated = false;
+
+    for (const event of events) {
+      if (event.timeout) {
+        clearTimeout(event.timeout);
+        delete event.timeout;
       }
+
+      if (!calculated) {
+        calculated = true;
+        _data = typeof data === "function" ? await data() : data;
+      }
+
+      event.callback(_data);
     }
   }
 
@@ -170,28 +251,81 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     _.remove(_events, (e) => !e || e?.once);
   }
 
-  function onEvent(name, callback, once, timeout) {
+  function onEvent({ name, id, callback, once, timeout }) {
     if (!events[name]) {
       events[name] = [];
     }
-    const t = timeout ? setTimeout(callback, timeout) : null;
+    if (!id) {
+      id = uuidv4();
+    }
+    const t = timeout
+      ? setTimeout(function () {
+          try {
+            callback?.();
+          } catch (e) {}
+          if (once) {
+            offEvent(id);
+          }
+        }, timeout)
+      : null;
     events[name].push({
+      id,
       once,
       callback,
       timeout: t,
     });
+    return id;
   }
 
+  // name, id, callback
   function offEvent(name) {
-    if (Array.isArray(events[name])) {
-      for (const eventElement of events[name]) {
-        if (eventElement.timeout) {
-          clearTimeout(eventElement.timeout);
-        }
+    if (!Array.isArray(name)) {
+      name = [name];
+    }
+    for (const nameE of name) {
+      switch (typeof nameE) {
+        case "string":
+          if (Array.isArray(events[nameE])) {
+            //name
+            for (const eventElement of events[nameE]) {
+              if (eventElement.timeout) {
+                clearTimeout(eventElement.timeout);
+              }
+            }
+            events[nameE] = [];
+          } else {
+            //id
+            for (const eventsKey in events) {
+              if (!Array.isArray(events[eventsKey])) {
+                continue;
+              }
+              const index = events[eventsKey].findIndex((e) => e.id === nameE);
+              if (index > -1) {
+                if (events[eventsKey].timeout) {
+                  clearTimeout(events[eventsKey].timeout);
+                }
+                events[eventsKey].splice(index, 1);
+              }
+            }
+          }
+          break;
+        case "function":
+          //callback
+          for (const eventsKey in events) {
+            if (!Array.isArray(events[eventsKey])) {
+              continue;
+            }
+            const index = events[eventsKey].findIndex((e) => e.callback === nameE);
+            if (index > -1) {
+              if (events[eventsKey].timeout) {
+                clearTimeout(events[eventsKey].timeout);
+              }
+              events[eventsKey].splice(index, 1);
+            }
+          }
+          break;
       }
     }
-
-    events[name] = [];
   }
 
   function onAnyEvent(callback) {
@@ -289,6 +423,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     console.log(`[${now}] [${getAccountInfoName()}]`, ...msg);
   }
 
+  function error(...msg) {
+    const now = moment().tz("Asia/Ho_Chi_Minh").format("DD/MM/YYYY HH:mm:ss");
+    console.error(`[${now}] [${getAccountInfoName()}]`, ...msg);
+  }
+
   async function getPersonas(steamIDs) {
     if (!steamIDs) return [];
     if (!Array.isArray(steamIDs)) {
@@ -355,14 +494,14 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     return (
       getCookies() ||
       new Promise((resolve) => {
-        onEvent(
-          "webSession",
-          function (webSession) {
+        onEvent({
+          name: "webSession",
+          callback: function (webSession) {
             resolve(webSession?.cookies);
           },
-          true,
-          30000,
-        );
+          once: true,
+          timeout: 30000,
+        });
       })
     );
   }
@@ -408,23 +547,33 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       rank = parseInt(Object.keys(RANKS).find((k) => RANKS[k] === rank)) * 10;
     }
 
-    const players = await new Promise((resolve) => {
-      steamClient.sendToGC(
-        AppID,
-        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
-        {},
-        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Search).protoEncode({
-          ver: CSGO_VER,
-          apr: prime ? 1 : 0,
-          ark: rank,
-          grps: [],
-          launcher: 0, // If we are using the China CSGO launcher or not*
-          game_type: gameTypeMap[game_type],
-        }),
-      );
-      lastTimePartySearch = Date.now();
-      pushGCCallback("partySearch", resolve, timeout);
-    });
+    const gcEventId = uuidv4();
+    const players = await ensureLogin(
+      new Promise((resolve) => {
+        lastTimePartySearch = Date.now();
+        onGCEvent({
+          name: gcEvents.partySearch,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: timeout,
+        });
+        steamClient.sendToGC(
+          AppID,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Search).protoEncode({
+            ver: CSGO_VER,
+            apr: prime ? 1 : 0,
+            ark: rank,
+            grps: [],
+            launcher: 0, // If we are using the China CSGO launcher or not*
+            game_type: gameTypeMap[game_type],
+          }),
+        );
+      }),
+    );
+    clearGCCallback(gcEventId);
+
     if (Array.isArray(players) && players.length) {
       const personas = await getPersonas(players.map((p) => p.steamId));
       for (const player of players) {
@@ -434,8 +583,8 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
           player.avatar_hash = persona.avatar_hash;
         }
       }
+      return players;
     }
-    return players;
   }
 
   async function createLobby() {
@@ -697,10 +846,20 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function requestCoPlays() {
-    return new Promise((resolve) => {
-      steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
-      pushGCCallback("RequestCoPlays", resolve, 30000);
-    });
+    const gcEventId = uuidv4();
+    const response = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.requestCoPlays,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: 30000,
+        });
+        steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
+      }),
+    );
+    clearGCCallback(gcEventId);
+    return response;
   }
 
   function bindEvent() {
@@ -712,62 +871,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         callEvent(events.disconnected, { eresult, msg });
 
         if (["ServiceUnavailable", "NoConnection"].includes(msg) && autoReconnect && !isLogOff) {
-          async function relogin(retry) {
-            if (isLogOff) {
-              console.error("Cannot relogin (logoff)");
-              return false;
-            } else if (retry <= 0) {
-              console.error("Cannot relogin");
-              return false;
-            } else {
-              const isSuccess = await login(true);
-              if (isSuccess) {
-                const loggedOnResponse = await new Promise((resolve) => {
-                  onEvent(SteamClientEvents.loggedOn, resolve, true, 180000);
-                });
-                if (loggedOnResponse) {
-                  console.log("Relogin success");
-                  return true;
-                } else {
-                  const isLogOff = await new Promise((resolve, reject) => {
-                    logOffEvent = resolve;
-                    setTimeout(resolve, 120000);
-                  });
-                  logOffEvent = null;
-                  if (isLogOff === true) {
-                    return false;
-                  }
-                  return await relogin(retry - 1);
-                }
-              } else {
-                const isLogOff = await new Promise((resolve, reject) => {
-                  logOffEvent = resolve;
-                  setTimeout(resolve, 120000);
-                });
-                logOffEvent = null;
-                if (isLogOff === true) {
-                  return false;
-                }
-                return await relogin(retry - 1);
-              }
-            }
-          }
-
-          const isLogOff = await new Promise((resolve, reject) => {
-            logOffEvent = resolve;
-            setTimeout(resolve, 60000);
-          });
-          logOffEvent = null;
-          if (isLogOff === true) {
-            offAllEvent();
-            doClearIntervals();
-          } else {
-            const isSuccess = await relogin(50);
-            if (!isSuccess) {
-              offAllEvent();
-              doClearIntervals();
-            }
-          }
+          reLogin();
         } else {
           offAllEvent();
           doClearIntervals();
@@ -802,7 +906,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         steamClient.webSession = webSession;
         callEvent(events.webSession, webSession);
       },
-      async receivedFromGC(appid, msgType, payload) {
+      receivedFromGC: async function (appid, msgType, payload) {
         const key = getECsgoGCMsgKey(msgType);
         switch (msgType) {
           case ESteamProto.EMsg.k_EMsgClientChatInvite: {
@@ -830,9 +934,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
-            const msg = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Account_RequestCoPlays).protoDecode(payload);
-            const personas = msg.players.map((p) => SteamID.fromIndividualAccountID(p.accountid));
-            callGCCallback("RequestCoPlays", personas);
+            callGCCallback({
+              name: gcEvents.requestCoPlays,
+              data() {
+                const msg = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Account_RequestCoPlays).protoDecode(payload);
+                return msg.players.map((p) => SteamID.fromIndividualAccountID(p.accountid));
+              },
+            });
             break;
           }
           case ESteamProto.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
@@ -1127,79 +1235,83 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
-            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_SearchResults).protoDecode(payload);
-            const entries = _.uniqBy(result.entries, "id");
-            //{
-            //   id: 144900402,
-            //   grp: 0,
-            //   game_type: 8,
-            //   apr: 1,
-            //   ark: 17,
-            //   loc: 20041,
-            //   accountid: 0
-            // }
-
-            //{
-            //   id: "76561199265943339",
-            //   rich_presence: [],
-            //   persona_state: null,
-            //   game_played_app_id: null,
-            //   game_server_ip: null,
-            //   game_server_port: null,
-            //   persona_state_flags: null,
-            //   online_session_instances: null,
-            //   persona_set_by_user: null,
-            //   player_name: "杀人不见血",
-            //   query_port: null,
-            //   steamid_source: null,
-            //   avatar_hash: "33994e26f1fe7e2093f8c7dee66c1ac91531050d",
-            //   last_logoff: null,
-            //   last_logon: null,
-            //   last_seen_online: null,
-            //   clan_rank: null,
-            //   game_name: null,
-            //   gameid: null,
-            //   game_data_blob: null,
-            //   clan_data: null,
-            //   clan_tag: null,
-            //   broadcast_id: null,
-            //   game_lobby_id: null,
-            //   watching_broadcast_accountid: null,
-            //   watching_broadcast_appid: null,
-            //   watching_broadcast_viewers: null,
-            //   watching_broadcast_title: null,
-            //   is_community_banned: null,
-            //   player_name_pending_review: null,
-            //   avatar_pending_review: null,
-            //   avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d.jpg",
-            //   avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_medium.jpg",
-            //   avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_full.jpg"
-            // }
-
-            const players = [];
-            if (entries.length) {
-              const FriendCode = (await import("csgo-friendcode")).default;
-              for (const player of entries) {
-                try {
-                  const prime = player.apr === 1 ? "PRIME" : "NON-PRIME";
-                  const loc = LOCS[player.loc] || player.loc;
-                  const steamId = SteamID.fromIndividualAccountID(player.id).getSteamID64();
-                  const friendCode = FriendCode.encode(steamId);
-
-                  // if ((LOCS[player.loc] == 'VN' || !LOCS[player.loc])) {
-                  players.push({
-                    prime,
-                    rank: RANKS[player.ark] !== undefined ? RANKS[player.ark] : player.ark,
-                    loc,
-                    steamId,
-                    friendCode,
-                  });
-                  // }
-                } catch (e) {}
-              }
-            }
-
-            callGCCallback("partySearch", players);
+            callGCCallback({
+              name: gcEvents.partySearch,
+              async data() {
+                const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_SearchResults).protoDecode(payload);
+                const entries = _.uniqBy(result.entries, "id");
+                //{
+                //   id: 144900402,
+                //   grp: 0,
+                //   game_type: 8,
+                //   apr: 1,
+                //   ark: 17,
+                //   loc: 20041,
+                //   accountid: 0
+                // }
+
+                //{
+                //   id: "76561199265943339",
+                //   rich_presence: [],
+                //   persona_state: null,
+                //   game_played_app_id: null,
+                //   game_server_ip: null,
+                //   game_server_port: null,
+                //   persona_state_flags: null,
+                //   online_session_instances: null,
+                //   persona_set_by_user: null,
+                //   player_name: "杀人不见血",
+                //   query_port: null,
+                //   steamid_source: null,
+                //   avatar_hash: "33994e26f1fe7e2093f8c7dee66c1ac91531050d",
+                //   last_logoff: null,
+                //   last_logon: null,
+                //   last_seen_online: null,
+                //   clan_rank: null,
+                //   game_name: null,
+                //   gameid: null,
+                //   game_data_blob: null,
+                //   clan_data: null,
+                //   clan_tag: null,
+                //   broadcast_id: null,
+                //   game_lobby_id: null,
+                //   watching_broadcast_accountid: null,
+                //   watching_broadcast_appid: null,
+                //   watching_broadcast_viewers: null,
+                //   watching_broadcast_title: null,
+                //   is_community_banned: null,
+                //   player_name_pending_review: null,
+                //   avatar_pending_review: null,
+                //   avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d.jpg",
+                //   avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_medium.jpg",
+                //   avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_full.jpg"
+                // }
+
+                const players = [];
+                if (entries.length) {
+                  const FriendCode = (await import("csgo-friendcode")).default;
+                  for (const player of entries) {
+                    try {
+                      const prime = player.apr === 1 ? "PRIME" : "NON-PRIME";
+                      const loc = LOCS[player.loc] || player.loc;
+                      const steamId = SteamID.fromIndividualAccountID(player.id).getSteamID64();
+                      const friendCode = FriendCode.encode(steamId);
+
+                      // if ((LOCS[player.loc] == 'VN' || !LOCS[player.loc])) {
+                      players.push({
+                        prime,
+                        rank: RANKS[player.ark] !== undefined ? RANKS[player.ark] : player.ark,
+                        loc,
+                        steamId,
+                        friendCode,
+                      });
+                      // }
+                    } catch (e) {}
+                  }
+                }
+                return players;
+              },
+            });
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
@@ -1270,7 +1382,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                   player.elo = ranking.rank_id;
                 }
               }
-              callGCCallback(`PlayersProfile_${player.account_id}`, player);
+              callGCCallback({
+                name: gcEvents.playersProfile,
+                data: player,
+                key: player.account_id,
+              });
             }
             callEvent(events.playersProfile, player);
             break;
@@ -1298,7 +1414,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
               res: null,
               errormsg: "Game is full",
             };
-            callGCCallback(`requestJoinFriendData_${data.account_id}`, data);
+            callGCCallback({
+              name: gcEvents.requestJoinFriendData,
+              data,
+              key: data.account_id,
+            });
             break;
           }
           default:
@@ -1316,6 +1436,36 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         }
       },
       async loggedOn(loggedOnResponse) {
+        const example = {
+          eresult: 1,
+          legacy_out_of_game_heartbeat_seconds: 9,
+          heartbeat_seconds: 9,
+          deprecated_public_ip: 250140346,
+          rtime32_server_time: 1727758337,
+          account_flags: 2642053,
+          cell_id: 71,
+          email_domain: null,
+          steam2_ticket: null,
+          eresult_extended: null,
+          webapi_authenticate_user_nonce: null,
+          cell_id_ping_threshold: 2147483647,
+          deprecated_use_pics: null,
+          vanity_url: "",
+          public_ip: {
+            v4: 250140346,
+          },
+          client_supplied_steamid: "76561190347696",
+          ip_country_code: "VN",
+          parental_settings: null,
+          parental_setting_signature: null,
+          count_loginfailures_to_migrate: 0,
+          count_disconnects_to_migrate: 0,
+          ogs_data_report_time_window: null,
+          client_instance_id: "4130450042302948",
+          force_client_update_check: false,
+          agreement_session_url: null,
+          token_id: null,
+        };
         callEvent(events.loggedOn, loggedOnResponse);
         updateInvisible();
         updateAutoRequestFreeLicense();
@@ -1663,20 +1813,31 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   /*
    * usually take 400 -> 800 miliseconds
    * */
-  function getPlayersProfile(steamId) {
+  async function getPlayersProfile(steamId) {
     const accountid = new SteamID(steamId).accountid;
-    steamClient.sendToGC(
-      730,
-      ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
-      {},
-      new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestPlayersProfile).protoEncode({
-        account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
-        request_level: 32,
+    const gcEventId = uuidv4();
+    const result = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.playersProfile,
+          key: accountid,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: 5000,
+        });
+        steamClient.sendToGC(
+          730,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestPlayersProfile).protoEncode({
+            account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
+            request_level: 32,
+          }),
+        );
       }),
     );
-    return new Promise((resolve) => {
-      pushGCCallback(`PlayersProfile_${accountid}`, resolve, 2000);
-    });
+    clearGCCallback(gcEventId);
+    return result;
   }
 
   async function checkPlayerPrimeStatus(steamId) {
@@ -1783,23 +1944,113 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     }
   }
 
-  async function login(reconnect = false) {
-    function logOn(clientJsToken) {
-      try {
-        steamClient.logOn({
-          ...clientJsToken,
-          steamId: new SteamID(clientJsToken.steamid),
-          steamID: new SteamID(clientJsToken.steamid),
-          accountName: clientJsToken.account_name,
-          webLogonToken: clientJsToken.token,
-        });
-        return true;
-      } catch (e) {
-        console.error(e);
-        return false;
-      }
+  /**
+   * Logs on to the Steam client using the provided token.
+   *
+   * @async
+   * @function logOn
+   *
+   * @param {Object} [token] - The token object containing credentials and other information. Defaults to a pre-filled sample token.
+   * @param {boolean} [token.logged_in=true] - Indicates whether the user is logged in.
+   * @param {string} [token.steamid="76561199027696"] - The user's SteamID in string format.
+   * @param {number} [token.accountid=10671968] - The user's account ID.
+   * @param {string} [token.account_name="helloword"] - The user's account name.
+   * @param {string} [token.accountName="helloword"] - The user's account name (duplicate).
+   * @param {boolean} [token.is_support=false] - Whether the user is a support member.
+   * @param {boolean} [token.is_limited=true] - Indicates if the user's account is limited.
+   * @param {boolean} [token.is_partner_member=false] - Whether the user is a partner member.
+   * @param {string} [token.country_code="CN"] - The user's country code.
+   * @param {string} [token.token="AAAAAAAAAAAAAAA"] - The web logon token.
+   * @param {string} [token.webLogonToken="AAAAAAAAAAAAAAA"] - The web logon token (duplicate).
+   * @param {string} [token.token_use_id="e6a33a62c1d403b71761301c"] - The token use ID.
+   * @param {Object} [token.steamId] - SteamID details.
+   * @param {Object} [token.steamID] - Duplicate SteamID object (legacy support).
+   *
+   * @returns {Promise<boolean>} Resolves to `true` if login is successful, `false` otherwise.
+   *
+   * @throws Will log an error to the console if the login fails.
+   */
+  async function logOn(token) {
+    try {
+      steamClient.logOn({
+        ...token,
+        steamId: new SteamID(token.steamid),
+        steamID: new SteamID(token.steamid),
+        accountName: token.account_name,
+        webLogonToken: token.token,
+      });
+      let timeout = null;
+      const eventIds = [];
+      const loggedOnResponse = await Promise.race([
+        new Promise((resolve) => {
+          timeout = setTimeout(function () {
+            resolve();
+          }, 180000);
+        }),
+        new Promise((resolve) => {
+          eventIds.push(
+            onEvent({
+              name: SteamClientEvents.loggedOn,
+              callback: resolve,
+              once: true,
+            }),
+            onEvent({
+              name: SteamClientEvents.logOff,
+              callback: function () {
+                resolve();
+              },
+              once: true,
+            }),
+            onEvent({
+              name: SteamClientEvents.error,
+              callback: function () {
+                resolve();
+              },
+              once: true,
+            }),
+          );
+        }),
+      ]);
+      clearTimeout(timeout);
+      offEvent(eventIds);
+      return loggedOnResponse?.eresult === 1;
+    } catch (e) {
+      console.error("logOn", e);
+      return false;
+    }
+  }
+
+  async function reLogin(retry = 50) {
+    if (isLogOff || retry <= 0) {
+      offAllEvent();
+      doClearIntervals();
+
+      error(`Cannot relogin (${isLogOff ? "logoff" : "retry limit reached"})`);
+      return false;
+    }
+
+    const isSuccess = await login(true);
+    if (isSuccess) {
+      log("Relogin success");
+      return true;
+    }
+
+    if (isLogOff) {
+      offAllEvent();
+      doClearIntervals();
+      error(`Cannot relogin (${isLogOff ? "logoff" : "retry limit reached"})`);
+      return false;
+    }
+
+    if (retry > 1) {
+      await sleep(60000);
+      return await reLogin(retry - 1);
+    } else {
+      return false;
     }
+  }
 
+  async function login(reconnect = false) {
     if (clientJsToken?.logged_in === true) {
       log(`[${clientJsToken.steamid}] ${reconnect ? "reconnect with clientJsToken" : "login with clientJsToken"}`);
       setTimeout(function () {
@@ -1814,27 +2065,33 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         return logOn(_clientJsToken);
       } else {
         log(`Account not logged in ${clientJsToken?.account_name || steamUser.getSteamIdUser() || ""}`);
-        console.log(clientJsToken);
-        return false;
       }
-    } else if (username && password) {
-      log(reconnect ? `reconnect with username ${username}` : `login with username ${username}`);
-      steamClient.logOn({
-        accountName: username,
-        password: password,
-        rememberPassword: true,
-        machineName: "Natri",
-      });
-      return true;
     } else {
       log(`Account not logged in ${clientJsToken?.account_name || ""}`);
       return false;
     }
   }
 
-  function logOff() {
+  function clearLogOffEvent(id) {
+    if (typeof id === "string") {
+      delete logOffEvents[id];
+      return id;
+    } else if (typeof id === "function") {
+      for (const idKey in logOffEvents) {
+        if (logOffEvents[idKey] === id) {
+          delete logOffEvents[idKey];
+          return idKey;
+        }
+      }
+    }
+  }
+
+  async function logOff() {
     isLogOff = true;
-    logOffEvent?.(true);
+
+    callEvent(events.logOff);
+    events.logOff = [];
+
     if (_cleanNodeSteamUserTimeout) {
       clearTimeout(_cleanNodeSteamUserTimeout);
     }
@@ -1849,25 +2106,41 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     steamClient.licenses = [];
 
     steamClient.logOff();
-  }
+    await sleep(5000);
+    delete steamClient._logOnDetails;
+    delete steamClient.logOnResult;
+    delete steamClient._httpClient;
+    delete steamClient._lastChosenCM;
+    try {
+      steamClient._connection.end();
+    } catch (e) {}
+    delete steamClient._connection;
+    delete steamClient.accountInfo;
+    delete steamClient.emailInfo;
+    delete steamClient.limitations;
+    delete steamClient.vac;
+    delete steamClient.wallet;
+    delete steamClient.licenses;
+    delete steamClient.gifts;
+    delete steamClient.myGroups;
+    delete steamClient.playingState;
 
-  function onCookie(callback) {
-    if (getCookies()) {
-      callback(getCookies());
-    } else {
-      onEvent(
-        "webSession",
-        function (webSession) {
-          callback(webSession?.cookies?.join?.(";"));
-        },
-        true,
-      );
+    delete steamClient._heartbeatInterval;
+    delete steamClient.chat;
+    delete steamClient._httpClient;
+    delete steamClient._events;
+    delete steamClient.picsCache;
+    delete steamClient.options;
+
+    for (const key in steamClient) {
+      delete steamClient[key];
     }
   }
 
   async function init() {
     bindEvent();
-    if (await login()) {
+    const logged = await login();
+    if (logged) {
       steamClient._handlerManager.add(ESteamProto.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
         const result = new SteamProto(SteamProtoType.CMsgClientRequestedClientStats).protoDecode(payload.toBuffer());
         // console.log("CMsgClientRequestedClientStats", result);
@@ -1998,40 +2271,54 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     isInvisible = false;
     isAutoPlay = true;
     isPartyRegister = false;
-    const online = await new Promise((resolve) => {
-      const timeout = setTimeout(function () {
-        resolve(false);
-      }, 60000);
 
-      onEvent(
-        SteamClientEvents.csgoOnline,
-        function () {
-          clearTimeout(timeout);
-          resolve(true);
-        },
-        true,
-      );
-      onEvent(
-        SteamClientEvents.error,
-        function () {
-          clearTimeout(timeout);
-          resolve(false);
-        },
-        true,
-      );
-      onEvent(
-        SteamClientEvents.playingState,
-        function ({ playing_blocked, playing_app }) {
-          if (playing_blocked) {
-            clearTimeout(timeout);
-            resolve(false);
-          }
-        },
-        true,
-      );
-      init();
-    });
-    offAllEvent();
+    let timeout = null;
+    const eventIds = [];
+
+    const online = await Promise.race([
+      new Promise((resolve) => {
+        setTimeout(function () {
+          resolve();
+        }, 60000);
+      }),
+      new Promise((resolve) => {
+        eventIds.push(
+          onEvent({
+            name: SteamClientEvents.logOff,
+            callback: function () {
+              resolve(false);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.csgoOnline,
+            callback: function () {
+              resolve(true);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.error,
+            callback: function () {
+              resolve(false);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.playingState,
+            callback: function ({ playing_blocked }) {
+              if (playing_blocked) {
+                resolve(false);
+              }
+            },
+          }),
+        );
+        init();
+      }),
+    ]);
+
+    clearTimeout(timeout);
+    offEvent(eventIds);
     return online;
   }
 
@@ -2248,7 +2535,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     return steamClient._playingAppIds || [];
   }
 
-  function requestJoinFriendData(token, version) {
+  async function requestJoinFriendData(token, version) {
     if (!steamClient.steamID) {
       return;
     }
@@ -2263,20 +2550,31 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     let accountID = conBuf.readInt32BE(4);
     let joinIpp = conBuf.readInt32BE(8);
 
-    return new Promise((resolve) => {
-      pushGCCallback(`requestJoinFriendData_${accountID}`, resolve, 30000);
-      steamClient.sendToGC(
-        AppID,
-        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
-        {},
-        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoEncode({
-          version: version || CSGO_VER,
-          account_id: accountID,
-          join_token: joinToken,
-          join_ipp: joinIpp,
-        }),
-      );
-    });
+    const gcEventId = uuidv4();
+    const response = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.requestJoinFriendData,
+          id: gcEventId,
+          key: accountID,
+          callback: resolve,
+          timeoutMs: 30000,
+        });
+        steamClient.sendToGC(
+          AppID,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoEncode({
+            version: version || CSGO_VER,
+            account_id: accountID,
+            join_token: joinToken,
+            join_ipp: joinIpp,
+          }),
+        );
+      }),
+    );
+    clearGCCallback(gcEventId);
+    return response;
   }
 
   function redeemFreeReward(itemIds, generation_time) {
@@ -2345,6 +2643,25 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     );
   }
 
+  async function ensureLogin(promise) {
+    const logOffEventId = uuidv4();
+    const result = await Promise.race([
+      new Promise((resolve) => {
+        onEvent({
+          name: SteamClientEvents.logOff,
+          id: logOffEventId,
+          callback: function () {
+            resolve(null);
+          },
+          once: true,
+        });
+      }),
+      promise,
+    ]);
+    offEvent(logOffEventId);
+    return result;
+  }
+
   return {
     init,
     partySearch,
@@ -2443,6 +2760,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       return state;
     },
     log,
+    error,
     isPrime() {
       return prime === true;
     },
@@ -2563,111 +2881,6 @@ export function increaseCSGO_VER() {
   return ++CSGO_VER;
 }
 
-SteamClient.isAccountPlayable = async function isAccountPlayable({ cookie, clientJsToken, timeoutMs, onPlayable, onNotPlayable, keepLoginWhenPlayable, ...rest }) {
-  if (!clientJsToken && cookie) {
-    clientJsToken = await new SteamUser(typeof cookie === "function" ? await cookie() : cookie).getClientJsToken();
-  }
-  if (clientJsToken?.logged_in !== true) {
-    if (typeof onNotPlayable === "function") {
-      await onNotPlayable(null);
-    }
-    return { invalidClientJsToken: true };
-  }
-  return await new Promise((resolve) => {
-    const timeouts = [
-      setTimeout(() => {
-        doResolve({ timedOut: true });
-      }, timeoutMs || 30000),
-    ];
-
-    const steamClient = new SteamClient({
-      isFakeGameScore: false,
-      isAutoPlay: true,
-      isPartyRegister: false,
-      isInvisible: true,
-      MAX_GAME_PLAY: 10,
-      games: 730,
-      clientJsToken,
-      ...rest,
-    });
-
-    steamClient.onEvent(
-      SteamClientEvents.error,
-      ({ eresult, msg, error }) => {
-        doResolve({ eresult, msg, error });
-      },
-      true,
-    );
-
-    steamClient.onEvent(
-      SteamClientEvents.csgoOnline,
-      (ClientWelcome) => {
-        doResolve({ playable: true });
-      },
-      true,
-    );
-
-    steamClient.onEvent(
-      SteamClientEvents.csgoClientHello,
-      (ClientHello) => {
-        doResolve({ playable: true });
-      },
-      true,
-    );
-
-    steamClient.onEvent(SteamClientEvents.playingState, ({ playing_blocked, playing_app }) => {
-      if (playing_blocked) {
-        doResolve({ playable: false });
-      } else {
-        timeouts.push(
-          setTimeout(function () {
-            const isBlocked = steamClient.isPlayingBlocked();
-            doResolve({ playable: !isBlocked });
-          }, 5000),
-        );
-      }
-    });
-
-    // steamClient.onEvent("fatalError", () => {
-    //   doResolve();
-    // });
-
-    steamClient.init();
-
-    async function doResolve(data) {
-      const playable = data?.playable === true;
-      timeouts.forEach((timeout) => clearTimeout(timeout));
-
-      if (!playable || !keepLoginWhenPlayable) {
-        steamClient.doClearIntervals();
-        steamClient.offAllEvent();
-      }
-
-      if (playable) {
-        if (typeof onPlayable === "function") {
-          try {
-            await onPlayable(steamClient);
-          } catch (e) {}
-        }
-      } else {
-        if (typeof onNotPlayable === "function") {
-          try {
-            await onNotPlayable(steamClient);
-          } catch (e) {}
-        }
-      }
-
-      if (!playable || !keepLoginWhenPlayable) {
-        steamClient.logOff();
-        return resolve(data);
-      } else {
-        steamClient.offAllEvent();
-        return resolve({ ...data, steamClient });
-      }
-    }
-  });
-};
-
 class XpBonuxFlagsHelper {
   static kCSXpBonusFlags_EarnedXpThisPeriod = 1 << 0;
   static kCSXpBonusFlags_FirstReward = 1 << 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "steamutils",
-  "version": "1.4.63",
+  "version": "1.4.64",
   "main": "index.js",
   "dependencies": {
     "alpha-common-utils": "^1.0.6",