steamutils 1.0.44 → 1.0.46

package/SteamClient.js

@@ -95,11 +95,67 @@ function SteamClient({
 
     const events = {
         loggedOn: [],
+        csgoOnline: [],
         webSession: [],
         friendMessage: [],
         friendTyping: [],
     }
 
+    const gcCallback = {}
+
+    function pushGCCallback(name, cb, timeout) {
+        if (!gcCallback[name]) {
+            gcCallback[name] = {}
+        }
+        let t = null
+        let id = uuidv4()
+
+        function callback(...arg) {
+            if (t) {
+                clearTimeout(t)
+            }
+            delete gcCallback[name][id]
+            cb(arg)
+        }
+
+        if (timeout) {
+            t = setTimeout(callback, timeout)
+        }
+        gcCallback[name][id] = callback
+    }
+
+    function callGCCallback(name, ...arg) {
+        if (gcCallback[name]) {
+            for (let id in gcCallback[name]) {
+                gcCallback[name][id](arg)
+            }
+        }
+    }
+
+    function callEvent(_events, data) {
+        _events.forEach((e) => {
+            e.callback?.(data)
+            e.timeout && clearTimeout(e.timeout)
+            delete e.timeout
+            if (e.once) {
+                delete e.callback
+            }
+        })
+        _.remove(_events, e => e.once)
+    }
+
+    function onEvent(name, callback, once, timeout) {
+        if (!events[name]) {
+            events[name] = []
+        }
+        const t = timeout ? setTimeout(callback, timeout) : null
+        events[name].push({
+            once,
+            callback,
+            timeout: t,
+        })
+    }
+
     const intervals = {}
 
     function doSetInterval(cb, timeout, key) {
@@ -113,6 +169,7 @@ function SteamClient({
             }
         }
         intervals[key] = setInterval(cb, timeout)
+        return key
     }
 
     function doClearIntervals() {
@@ -126,6 +183,10 @@ function SteamClient({
         return [steamClient?.accountInfo?.name, steamClient?._logOnDetails?.account_name].filter(Boolean).join(" - ")
     }
 
+    function log(msg) {
+        console.log(`[${getAccountInfoName()}] ${msg}`)
+    }
+
     async function getPersonas(steamIDs) {
         steamIDs = steamIDs.map(steamID => steamID instanceof SteamID ? steamID.getSteamID64() : steamID)
         const notCachesteamIDs = steamIDs.filter(id => !PersonasCache.some(p => p.id == id))
@@ -165,13 +226,12 @@ function SteamClient({
         return cachedPersonas
     }
 
-    const sleep = (ms) => {
+    function sleep(ms) {
         return new Promise(resolve => {
             setTimeout(resolve, ms)
         })
     }
 
-    const partySearchCallback = []
 
     /**
      * Get a list of lobbies (* = Unsure description could be wrong)
@@ -199,33 +259,26 @@ function SteamClient({
                 launcher: 0,
                 game_type: game_type === 'Competitive' ? 8 : 10
             }))
-            partySearchCallback.push(resolve)
-            setTimeout(resolve, timeout)
+            pushGCCallback('partySearch', resolve, timeout)
         })
     }
 
     async function sendHello() {
-        console.log('sendHello', getAccountInfoName())
         steamClient.sendToGC(appid, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello, {}, Buffer.alloc(0))
         steamClient.sendToGC(appid, Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientHello, {}, Buffer.alloc(0))
-        console.log('sendHello done', getAccountInfoName())
     }
 
-    const requestCoPlaysCallback = []
-
     async function requestCoPlays() {
-        console.log('sendMessageAccount_RequestCoPlays')
         return new Promise(resolve => {
             steamClient.sendToGC(appid, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0))
-            requestCoPlaysCallback.push(resolve)
-            setTimeout(resolve, 10000)
+            pushGCCallback('RequestCoPlays', resolve, 30000)
         })
     }
 
 
     function bindEvent() {
         steamClient.on('disconnected', async (eresult, msg) => {
-            console.log('disconnected', eresult, msg)
+            log('disconnected', eresult, msg)
             doClearIntervals()
         })
         steamClient.on('error', async (e) => {
@@ -248,26 +301,26 @@ function SteamClient({
                     errorStr = `Unknown: ${e.eresult}`
                     break
             }
-            console.log('error', e?.message)
+            log('error', e?.message)
             doClearIntervals()
         })
 
         steamClient.on('webSession', (sessionID, cookies) => {
             const webSession = {sessionID, cookies};
             steamClient.webSession = webSession
-            events.webSession.forEach(e => e?.(webSession))
+            callEvent(events.webSession, webSession)
         })
 
         steamClient.on('receivedFromGC', async (appid, msgType, payload) => {
             const key = getECsgoGCMsgKey(msgType)
             switch (msgType) {
                 case Protos.csgo.EMsg.k_EMsgClientChatInvite: {
-                    console.log(payload)
+                    log(payload)
                     break
                 }
                 case Protos.csgo.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
                     let msg = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload)
-                    console.log(msg)
+                    log(msg)
                     break
                 }
                 case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
@@ -276,16 +329,16 @@ function SteamClient({
                     const personas = await getPersonas([sid64]);
                     const player_name = personas.find(p => p.id == sid64)?.player_name
                     if (player_name === undefined) {
-                        console.log(sid64, personas);
+                        log(sid64, personas);
                     }
-                    console.log(getAccountInfoName(), player_name, `https://steamcommunity.com/profiles/${sid64}`);
+                    log(getAccountInfoName(), player_name, `https://steamcommunity.com/profiles/${sid64}`);
                     // joinLobby(msg.lobbyid, msg.accountid)
                     break
                 }
                 case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
                     const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Account_RequestCoPlays, payload);
                     const personas = msg.players.map(p => SteamID.fromIndividualAccountID(p.accountid));
-                    requestCoPlaysCallback?.shift()?.(personas)
+                    callGCCallback('RequestCoPlays', personas)
                     break
                 }
                 case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
@@ -307,9 +360,13 @@ function SteamClient({
                                     }
                                     break
                                 }
+                                default: {
+                                    log("cache_object.type_id", cache_object.type_id);
+                                }
                             }
                         }
                     }
+                    callEvent(events.csgoOnline)
                     break
                 }
                 case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
@@ -461,11 +518,7 @@ function SteamClient({
                         }
                     }
 
-
-                    let _partySearchCallback = null
-                    while ((_partySearchCallback = partySearchCallback.shift())) {
-                        _partySearchCallback?.(players)
-                    }
+                    callGCCallback('partySearch', players)
                     break
                 }
                 case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
@@ -506,16 +559,13 @@ function SteamClient({
                         player_cur_xp: 327682846,
                         player_xp_bonus_flags: 0
                     }]
-                    console.log(data);
 
                     const accountid = data?.[0]?.account_id
-                    const cb = getPlayersProfileCallback[accountid]
-                    delete getPlayersProfileCallback[accountid]
-                    cb?.(data?.[0])
+                    callGCCallback('PlayersProfile' + accountid, data?.[0])
                     break
                 }
                 default:
-                    console.log(`receivedFromGC ${msgType} ${key}`)
+                    log(`receivedFromGC ${msgType} ${key}`)
                     const results = Object.values(Protos.csgo).map(function (p) {
                         try {
                             return protoDecode(p, payload)
@@ -524,7 +574,7 @@ function SteamClient({
                     }).filter(function (result) {
                         return result && Object.keys(result).length
                     })
-                    console.log(key, results)
+                    log(key, results)
             }
         })
 
@@ -572,38 +622,38 @@ function SteamClient({
                 await sleep(1000)
             }
 
-            console.log(`app ${appid} launched on account ${getAccountInfoName()}`)
+            log(`app ${appid} launched`)
             await sendHello()
 
-            events.loggedOn.forEach(e => e?.())
+            callEvent(events.loggedOn)
         })
 
         steamClient.on('friendMessage', async (user, message) => {
             const sid64 = user.getSteamID64();
             const personas = await getPersonas([sid64]);
             const player_name = personas[sid64]?.player_name || ''
-            console.log('friendMessage', sid64, message);
+            log('friendMessage', sid64, message);
 
-            if ([`Invited you to play a game!`, `Đã mời bạn chơi một trò chơi!`].includes(message)) {
-                if (events.friendMessage.length) {
-                    events.friendMessage.forEach(e => e?.({
-                        player_name,
-                        message,
-                        invite: true,
-                        sid64,
-                    }))
-                }
+            if ([`Inited you to play a game!`, `Đã mời bạn chơi một trò chơi!`].includes(message)) {
+                callEvent(events.friendMessage, {
+                    player_name,
+                    message,
+                    invite: true,
+                    sid64,
+                })
             } else {
-                events.friendMessage.forEach(e => e?.({
+                callEvent(events.friendMessage, {
                     message,
                     player_name,
                     sid64,
-                }))
+                })
             }
         });
 
         steamClient.on('friendTyping', async function (steamID, message) {
-            events.friendTyping.forEach(e => e?.(steamID, message))
+            callEvent(events.friendTyping, {
+                steamID, message
+            })
         });
     }
 
@@ -612,19 +662,30 @@ function SteamClient({
     }
 
 
-    const getPlayersProfileCallback = {};
-
     function getPlayersProfile(accountid) {
         steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestPlayersProfile, {
             account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
             request_level: 32
         }))
         return new Promise(resolve => {
-            getPlayersProfileCallback[accountid] = resolve
-            setTimeout(resolve, 30000)
+            pushGCCallback('PlayersProfile' + accountid, resolve, 30000)
         })
     }
 
+    async function checkPlayerPrimeStatus(accountid) {
+        const profile = await getPlayersProfile(accountid)
+        if (!profile) return false
+
+        if (profile.ranking?.account_id) {
+            return true
+        }
+
+        if (profile.player_level || profile.player_cur_xp) {
+            return true
+        }
+        return false
+    }
+
     async function getNewCookie(cookie) {
         let response = (await axios.request({
             url: 'https://store.steampowered.com/', headers: {
@@ -669,7 +730,7 @@ function SteamClient({
             return cookie
         } else {
             if (tryNewCookie) {
-                console.log('You are not logged in', cookie)
+                log('You are not logged in', cookie)
                 return null
             } else {
                 return await loginWithCookie(await getNewCookie(cookie), true)
@@ -679,13 +740,13 @@ function SteamClient({
 
     async function login() {
         if (cookie) {
-            console.log('login with cookie')
+            log('login with cookie')
             const newCookie = await loginWithCookie(cookie)
             if (newCookie) {
                 cookie = newCookie
             }
         } else if (username && password) {
-            console.log(`login with username ${username}`)
+            log(`login with username ${username}`)
             steamClient.logOn({
                 accountName: username, password: password, rememberPassword: true, machineName: 'Natri',
             })
@@ -699,14 +760,16 @@ function SteamClient({
 
 
     function partyRegister() {
-        _partyRegister(prime)
         if (prime === null) {
             _partyRegister(true)
+            _partyRegister(false)
+        } else {
+            _partyRegister(prime)
         }
     }
 
     function _partyRegister(prime) {
-        console.log("partyRegister", getAccountInfoName(), prime);
+        log("partyRegister", prime);
         steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Register, {
             // id : 0,
             ver: CSGO_VER, apr: prime ? 1 : 0,//prime
@@ -733,14 +796,16 @@ function SteamClient({
         }
     }
 
-    async function autoRequestFreeLicense(log = false, max = 10) {
+    async function autoRequestFreeLicense(shouldLog = false, max = 10) {
         const steamUtils = new SteamUtils(getCookie())
 
-        const ownedAppsCount = log ? ((await steamUtils.getDynamicStoreUserData())?.rgOwnedApps?.length || 0) : 0
+        const ownedApps = (await steamUtils.getDynamicStoreUserData())?.rgOwnedApps || []
+        const ownedAppsCount = shouldLog ? (ownedApps?.length || 0) : 0
         let recommendedApps = Math.random() > 0.5 ? _.shuffle((await steamUtils.getDynamicStoreUserData())?.rgRecommendedApps || []) : []
         if (!recommendedApps?.length) {
             recommendedApps = (await axios.request({url: 'https://raw.githubusercontent.com/5x/easy-steam-free-packages/master/src/script/packages_db.json'}))?.data?.packages || []
         }
+        _.remove(recommendedApps, app => ownedApps.includes(app))
 
         if (max) {
             recommendedApps.length = Math.min(recommendedApps.length, max)
@@ -755,16 +820,16 @@ function SteamClient({
                 try {
                     await steamClient.requestFreeLicense(recommendedApp)
                 } catch (e) {
-                    console.log(e);
+                    log(e);
                 }
             }
             await sleep(2000)
         }
-        if (log) {
+        if (shouldLog) {
             await sleep(20000)
             const ownedAppsCount2 = (await steamUtils.getDynamicStoreUserData())?.rgOwnedApps?.length || 0
             const increaseNumber = ownedAppsCount2 - ownedAppsCount;
-            console.log(getAccountInfoName(), `OwnedApps length ${ownedAppsCount2}, increase ${increaseNumber}`)
+            log(getAccountInfoName(), `OwnedApps length ${ownedAppsCount2}, increase ${increaseNumber}`)
         }
     }
 
@@ -782,6 +847,22 @@ function SteamClient({
         steamClient.setPersona(SteamUser.EPersonaState.LookingToPlay)
     }
 
+    async function gamesPlayed(apps) {
+        steamClient.gamesPlayed(apps);
+        await sleep(2000)
+        steamClient.setPersona(SteamUser.EPersonaState.LookingToPlay)
+        sendHello()
+        // await sleep(10000)
+        // self.steamUser.uploadRichPresence(730, {
+        //     status: 'bussssss',
+        //     'game:state': 'lobby',
+        //     steam_display: '#display_watch',
+        //     currentmap: '#gamemap_de_empire',
+        //     connect: '+gcconnectG082AA752',
+        //     'game:mode': 'competitive'
+        // })
+    }
+
     return {
         init,
         partySearch,
@@ -795,15 +876,7 @@ function SteamClient({
         getLogOnDetails() {
             return steamClient?._logOnDetails
         },
-        onEvent(name, cb) {
-            if (!events[name]) {
-                events[name] = []
-            }
-            events[name].push(cb)
-        },
-        onEventLoggedOn(cb) {
-            events.loggedOn.push(cb)
-        },
+        onEvent,
         setPersona(state, name) {
             steamClient.setPersona(state, name)
         },
@@ -821,12 +894,9 @@ function SteamClient({
         playCSGO,
         doSetInterval,
         doClearIntervals,
-        async gamesPlayed(apps) {
-            steamClient.gamesPlayed(apps);
-            await sleep(2000)
-            steamClient.setPersona(SteamUser.EPersonaState.LookingToPlay)
-            sendHello()
-        }
+        gamesPlayed,
+        sendHello,
+        checkPlayerPrimeStatus,
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "steamutils",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "dependencies": {
     "axios": "^1.3.4",
     "cheerio": "^1.0.0-rc.12",

package/utils.js

@@ -34,7 +34,7 @@ const minDate = new Date(0),
     maxDate = new Date(parseInt('ffffffff', 16) * 1000)
 
 export function objectIdFromDate(date) {
-    if(date < minDate || date > maxDate) {
+    if (date < minDate || date > maxDate) {
         return 'Error: date must be between ' + minDate.getFullYear() + ' and ' + maxDate.getFullYear()
     }
     var pad = '00000000'
@@ -56,13 +56,13 @@ export function console_log(...args) {
 }
 
 export function removeSpaceKeys(object) {//mutate object
-    if(!object || Array.isArray(object)) {
+    if (!object || Array.isArray(object)) {
         return object
     }
 
     Object.entries(object).forEach(([key, value]) => {
         const newKey = key.replaceAll(/[^a-zA-Z0-9]/gi, '_')
-        if(newKey !== key) {
+        if (newKey !== key) {
             delete object[key]
             object[newKey] = value
         }
@@ -71,7 +71,7 @@ export function removeSpaceKeys(object) {//mutate object
 }
 
 export function getCleanObject(object) {//like removeSpaceKeys but not mutate object
-    if(!object || Array.isArray(object)) {
+    if (!object || Array.isArray(object)) {
         return object
     }
 
@@ -98,3 +98,34 @@ export function JSON_stringify(data) {
         return null
     }
 }
+
+
+export async function throttle(fn, delay) {
+    let canFire = true
+    let queue = []
+
+    async function pop() {
+        if (queue.length < 1) return
+
+        const [that, args] = queue.pop()
+        await fn.apply(that, args)
+        canFire = false
+        setTimeout(async () => {
+            canFire = true
+            await pop()
+        }, delay)
+    }
+
+    async function push() {
+        queue.push([this, arguments])
+        if (canFire) {
+            await pop()
+        }
+    }
+
+    push.cancel = () => {
+        queue = []
+    }
+
+    return push
+}