steamutils 1.5.37 → 1.5.39

package/index.js

@@ -4,8 +4,6 @@ import _ from "lodash";
 import moment from "moment";
 import { hex2b64, Key as RSA } from "node-bignumber";
 import SteamID from "steamid";
-import URL from "url";
-import Url from "url-parse";
 import qs from "qs";
 import { console_log, convertLongsToNumbers, downloadImage, formatMarketHistoryDate, getCleanObject, getImageSize, JSON_parse, JSON_stringify, removeSpaceKeys, secretAsBuffer, sleep } from "./utils.js";
 import { Header, request } from "./axios.js";
@@ -1057,91 +1055,20 @@ export default class SteamUser {
       throw new Error(`[${this._sessionId}] You have not set cookie yet`);
     }
 
-    if (typeof params === "string") {
-      params = { url: params };
-    }
-    const isRedirect = typeof params.isRedirect === "boolean" ? params.isRedirect : true;
-    delete params.isRedirect;
-    if (!params.url.startsWith("http")) {
-      params.url = _.trimEnd(SteamcommunityURL, "/") + "/" + _.trimStart(params.url, "/");
-    }
-    const originalURL = params.url;
-
-    //format URL
-    const urlObject = URL.parse(params.url);
-    const queryList = (urlObject.query || "")
-      .split("&")
-      .map((query) => query.trim())
-      .filter(Boolean);
-    if (!queryList.some((q) => q.toLowerCase().startsWith("sessionid".toLowerCase()))) {
-      queryList.push(`sessionid=${this.getSessionid()}`);
-    }
-    if (!queryList.some((q) => q.toLowerCase().startsWith("l".toLowerCase()))) {
-      queryList.push(`l=english`);
-    }
-    const protocol = urlObject.protocol ? `${urlObject.protocol}//${urlObject.host}` : "";
-    params.url = `${protocol}${urlObject.pathname}?${queryList.join("&")}`;
-
-    if (!(params.headers instanceof Header)) {
-      params.headers = new Header(params.headers);
-    }
-
-    params.headers.set({
-      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-      "accept-language": "en-US,en;q=0.9",
-      "cache-control": "no-cache",
-      pragma: "no-cache",
-      "sec-ch-ua": '"Not A(Brand";v="99", "Google Chrome";v="121", "Chromium";v="121"',
-      "sec-ch-ua-mobile": "?0",
-      "sec-ch-ua-platform": '"Windows"',
-      "sec-fetch-dest": "document",
-      "sec-fetch-mode": "navigate",
-      "sec-fetch-site": "none",
-      "sec-fetch-user": "?1",
-      "upgrade-insecure-requests": "1",
-      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
-    });
-
-    if (params.ajax) {
-      params.headers.set({
-        "X-KL-Ajax-Request": "Ajax_Request",
-        "X-Prototype-Version": "1.7",
-        "X-Requested-With": "XMLHttpRequest",
-      });
-    }
-    delete params.ajax;
-
-    let referer = params.headers.get("referer");
-    if (!referer) {
-      const urlObject = URL.parse(params.url);
-      if (urlObject.protocol && urlObject.host) {
-        referer = urlObject.protocol + "//" + urlObject.host;
-      } else {
-        referer = SteamcommunityURL;
-      }
-      params.headers.set("referer", referer);
-    }
-
-    if (!params.method) {
-      params.method = "GET";
-    }
-
-    params.method = params.method.toUpperCase();
-    if (!params.timeout) {
-      params.timeout = 2 * 60000;
-    }
+    const normalizedParams = normalizeParams(params, this.getSessionid());
 
     let response = null;
     const maxRedirect = 10;
     let redirectCount = 0;
 
-    async function __httpRequest(_params, cookie) {
+    async function requestOnce(_params, cookie) {
       let data = params.data ? params.data : {};
       const _sessionId = cookie.getCookie("sessionid");
       if (!_sessionId) return;
 
       if (params.method === "POST") {
-        if (params.headers.get("content-type")?.toLowerCase() === "multipart/form-data".toLowerCase()) {
+        const contentType = params.headers.get("content-type")?.toLowerCase();
+        if (contentType === "multipart/form-data") {
           if (data && !(data instanceof FormData) && typeof data === "object") {
             const form = new FormData();
             for (const name in data) {
@@ -1202,6 +1129,9 @@ export default class SteamUser {
         data,
       };
 
+      delete config.originalURL;
+      delete config.isRedirect;
+
       let _response = null;
       try {
         if (SteamUser.LOG_REQUEST) {
@@ -1233,7 +1163,7 @@ export default class SteamUser {
       }
 
       if (_response?.status === 302 && !redirectURL?.startsWith("https://steamcommunity.com/login/") && redirectCount++ < maxRedirect) {
-        return await __httpRequest(
+        return await requestOnce(
           {
             ...config,
             headers: {
@@ -1249,14 +1179,14 @@ export default class SteamUser {
       return _response;
     }
 
-    async function __httpRequestByCookies(cookies) {
+    async function tryRequestWithCookies(cookies, params) {
       if (!Array.isArray(cookies)) {
         cookies = [cookies];
       }
 
       for (const cookie of cookies) {
         redirectCount = 0;
-        response = await __httpRequest(
+        response = await requestOnce(
           {
             baseURL: SteamcommunityURL,
             ...params,
@@ -1266,32 +1196,13 @@ export default class SteamUser {
         );
 
         if (response) {
-          const html = response?.data;
-          if (html && typeof html === "string") {
-            const $ = cheerio.load(html.replaceAll(/[\t\n\r]/gi, "").trim());
-            const title = $("head > title").text().trim();
-            const errorMsg = $("#error_msg").text().trim();
-            const headline = $("#headline").text().trim();
-
-            if (title && SteamErrorTitle.includes(title)) {
-              return new ResponseError({
-                message: errorMsg || "Steam Community :: Error",
-                steamId: self._steamIdUser,
-                originalURL,
-              });
-            } else if (title === "Error" && headline === "Something Went Wrong") {
-              return new ResponseError({
-                message: headline,
-                detail: $("#message").text().trim(),
-                steamId: self._steamIdUser,
-                originalURL,
-              });
-            }
-          }
+          // Try to parse steam "HTML" errors
+          const htmlError = parseSteamHtmlError(response?.data, params.originalURL, self._steamIdUser);
+          if (htmlError) return htmlError;
 
           switch (response.status) {
             case 302: {
-              if (isRedirect) {
+              if (params.isRedirect) {
                 const redirectURL = response.headers.location;
 
                 if (redirectURL?.startsWith("https://steamcommunity.com/id/")) {
@@ -1300,7 +1211,7 @@ export default class SteamUser {
                     self._customURL = customURL;
                   }
                 } else if (redirectURL?.startsWith("https://steamcommunity.com/login/")) {
-                  console.error("Login first", originalURL, self._steamIdUser);
+                  console.error("Login first", params.originalURL, self._steamIdUser);
                   if (self._steamIdUser) {
                     eventEmitter.emit("login_first", {
                       steamId: self._steamIdUser,
@@ -1311,7 +1222,7 @@ export default class SteamUser {
                   response = new ResponseError({
                     loginFirst: true,
                     steamId: self._steamIdUser,
-                    originalURL,
+                    originalURL: params.originalURL,
                   });
                   continue;
                 }
@@ -1392,13 +1303,13 @@ export default class SteamUser {
       }
     }
 
-    await __httpRequestByCookies(this._cookies);
+    await tryRequestWithCookies(this._cookies, normalizedParams);
 
     if (response instanceof ResponseError && response.loginFirst && typeof self._refreshCookie === "function") {
       //refresh cookie
       const newCookie = await self._refreshCookie();
       if (newCookie) {
-        await __httpRequestByCookies(newCookie);
+        await tryRequestWithCookies(newCookie, normalizedParams);
 
         if (!(response instanceof ResponseError)) {
           if (typeof self._onRefreshCookie === "function") {
@@ -1407,7 +1318,6 @@ export default class SteamUser {
           self._cookies.unshift(new CookieManager(newCookie));
         }
       }
-      console.log("");
     }
 
     // while (--retry) {
@@ -1668,38 +1578,42 @@ export default class SteamUser {
 
   static _formatGroupLink({ link, gid, groupURL, page, content_only, searchKey, pathname = "" }) {
     searchKey = searchKey?.trim?.();
+
+    // Build the path if no link provided
     if (!link) {
       link = gid ? `gid/${gid}/?p=${page}` : `groups/${groupURL}/?p=${page}`;
     }
-    link = new Url(link);
-    link.query =
-      "?" +
-      [
-        ...link.query
-          .removePrefix("?")
-          .split("&")
-          .map((q) => q.split("="))
-          .filter((q) => !["searchKey", "content_only"].includes(q[0]))
-          .map((q) => q.join("=")),
-        !!content_only && `content_only=true`,
-        !!searchKey && `searchKey=${encodeURIComponent(searchKey)}`,
-      ]
-        .filter(Boolean)
-        .join("&");
 
+    // Always build an absolute URL
+    let base = SteamcommunityURL.endsWith("/") ? SteamcommunityURL : SteamcommunityURL + "/";
+
+    // Try to guard against double slash, e.g., if link starts with /
+    let urlStr = link.startsWith("http://") || link.startsWith("https://") ? link : link.startsWith("/") ? base.replace(/\/$/, "") + link : base + link;
+
+    const urlObj = new URL(urlStr);
+
+    // Remove searchKey and content_only from query
+    urlObj.searchParams.delete("searchKey");
+    urlObj.searchParams.delete("content_only");
+
+    // Add/overwrite provided query parameters
+    if (content_only) urlObj.searchParams.set("content_only", "true");
+    if (searchKey) urlObj.searchParams.set("searchKey", encodeURIComponent(searchKey));
+
+    // Pathname adjustment
     if (pathname) {
-      let _pathname = link.pathname.removeSuffix("/");
+      let _pathname = urlObj.pathname.replace(/\/$/, "");
       if (!_pathname.endsWith(pathname)) {
-        link.pathname = _pathname + "/" + pathname + "/";
+        urlObj.pathname = _pathname + "/" + pathname.replace(/^\//, "") + "/";
       }
     }
 
-    Object.assign(link, _.pick(new Url(SteamcommunityURL), ["slashes", "host", "hostname", "origin", "protocol"]));
-    if (link.pathname && !link.pathname.startsWith("/")) {
-      link.pathname = "/" + link.pathname;
+    // Ensure leading "/" for pathname
+    if (urlObj.pathname && !urlObj.pathname.startsWith("/")) {
+      urlObj.pathname = "/" + urlObj.pathname;
     }
 
-    return link.toString();
+    return urlObj.toString();
   }
 
   static _parseGroupInfo(html) {
@@ -5966,20 +5880,16 @@ export default class SteamUser {
 
   static parseTradeURL(tradeURL) {
     try {
-      const tradeURLParams = URL.parse(tradeURL)
-        .query.split("&")
-        .reduce(
-          (accumulator, currentValue, index) => ({
-            ...accumulator,
-            [currentValue.split("=")[0]]: currentValue.split("=")[1],
-          }),
-          {},
-        );
+      const urlObj = new URL(tradeURL);
+      const params = urlObj.searchParams;
+
+      const partner = params.get("partner");
+      const token = params.get("token");
 
       return {
-        accountId: tradeURLParams.partner,
-        steamId: SteamID.fromIndividualAccountID(tradeURLParams.partner).getSteamID64(),
-        token: tradeURLParams.token,
+        accountId: partner,
+        steamId: partner ? SteamID.fromIndividualAccountID(partner).getSteamID64() : undefined,
+        token: token,
       };
     } catch (e) {}
   }
@@ -7215,6 +7125,27 @@ export default class SteamUser {
     ];
   }
 
+  /**
+   * @typedef {Object} RedeemPointsResponse
+   * @property {number[]} bundle_community_item_ids - Array of community item IDs in the bundle. May be empty.
+   * @property {number} communityitemid - The redeemed community item ID.
+   */
+
+  /**
+   * Redeems Steam Points for a specified reward definition.
+   *
+   * @async
+   * @param {string} accessToken - The user's Steam OAuth access token.
+   * @param {number|string} definitionId - The definition ID for the reward to redeem.
+   * @returns {Promise<?RedeemPointsResponse>} A promise that resolves to the redemption response object,
+   * or null/undefined if unsuccessful.
+   *
+   * @example
+   * {
+   *   bundle_community_item_ids: [],
+   *   communityitemid: 34336330688
+   * }
+   */
   async redeemPoints(accessToken, definitionId) {
     if (!definitionId) {
       return;
@@ -7516,6 +7447,49 @@ export default class SteamUser {
     };
   }
 
+  /**
+   * Enumerates all refresh tokens associated with the given Steam access token.
+   *
+   * Makes a POST request to the Steam API to retrieve all refresh tokens for the provided access token.
+   *
+   * @async
+   * @param {string} accessToken - The Steam access token to enumerate tokens for.
+   * @returns {Promise<{
+   *   response: {
+   *     refresh_tokens: Array<{
+   *       token_id: string,
+   *       token_description: string,
+   *       time_updated: number,
+   *       platform_type: number,
+   *       logged_in: boolean,
+   *       os_platform: number,
+   *       auth_type: number,
+   *       gaming_device_type?: number,
+   *       first_seen: {
+   *         time: number
+   *       },
+   *       last_seen: {
+   *         time: number,
+   *         ip?: {
+   *           v4?: number
+   *         },
+   *         country?: string,
+   *         state?: string,
+   *         city?: string
+   *       },
+   *       os_type: number,
+   *       authentication_type: number
+   *     }>,
+   *     requesting_token: string
+   *   }
+   * } | undefined>} Resolves with Steam API token enumeration response on success, or undefined on invalid input or network error.
+   *
+   * @example
+   * const tokens = await enumerateTokens(mySteamAccessToken);
+   * if (tokens) {
+   *   console.log(tokens.response.refresh_tokens);
+   * }
+   */
   async enumerateTokens(accessToken) {
     if (!accessToken || typeof accessToken !== "string") {
       console.error("revokeAccessToken", "invalid accessToken", accessToken);
@@ -7539,37 +7513,6 @@ export default class SteamUser {
     }
 
     return result?.data;
-
-    const data = {
-      response: {
-        refresh_tokens: [
-          {
-            token_id: "6524101908770518402",
-            token_description: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
-            time_updated: 1713256963,
-            platform_type: 2,
-            logged_in: true,
-            os_platform: 2,
-            auth_type: 4,
-            first_seen: {
-              time: 1713256963,
-            },
-            last_seen: {
-              time: 1715595247,
-              ip: {
-                v4: 250140346,
-              },
-              country: "VN",
-              state: "Ha Noi",
-              city: "Hanoi",
-            },
-            os_type: 0,
-            authentication_type: 2,
-          },
-        ],
-        requesting_token: "6524101908770518402",
-      },
-    };
   }
 
   async hasToken(accessToken, tokenId) {
@@ -7880,6 +7823,87 @@ export default class SteamUser {
     return response;
   }
 
+  /**
+   * @typedef {Object} SteamStoreItemsResponse
+   * @property {Array<SteamStoreItem>} store_items - Array of store item objects.
+   */
+
+  /**
+   * @typedef {Object} SteamStoreItem
+   * @property {Array} included_types
+   * @property {Array} included_appids
+   * @property {Array<number>} content_descriptorids
+   * @property {Array} tagids
+   * @property {Array} tags
+   * @property {Array} purchase_options
+   * @property {Array} accessories
+   * @property {Array} supported_languages
+   * @property {number} item_type
+   * @property {number} id
+   * @property {number} success
+   * @property {boolean} visible
+   * @property {boolean} unvailable_for_country_restriction
+   * @property {string} name
+   * @property {string} store_url_path
+   * @property {number} appid
+   * @property {number} type
+   * @property {boolean} is_free
+   * @property {boolean} is_early_access
+   * @property {?null} related_items
+   * @property {?null} included_items
+   * @property {SteamStoreItemCategories} categories
+   * @property {?null} reviews
+   * @property {?null} basic_info
+   * @property {SteamStoreItemAssets} assets
+   * @property {?null} release
+   * @property {?null} platforms
+   * @property {?null} game_rating
+   * @property {?null} best_purchase_option
+   * @property {?null} self_purchase_option
+   * @property {?null} screenshots
+   * @property {?null} trailers
+   * @property {string} store_url_path_override
+   * @property {?null} free_weekend
+   * @property {boolean} unlisted
+   * @property {number} game_count
+   * @property {string} internal_name
+   * @property {string} full_description
+   * @property {boolean} is_free_temporarily
+   * @property {?null} assets_without_overrides
+   * @property {?null} user_filter_failure
+   */
+
+  /**
+   * @typedef {Object} SteamStoreItemCategories
+   * @property {Array<number>} supported_player_categoryids
+   * @property {Array<number>} feature_categoryids
+   * @property {Array<number>} controller_categoryids
+   */
+
+  /**
+   * @typedef {Object} SteamStoreItemAssets
+   * @property {string} asset_url_format
+   * @property {string} main_capsule
+   * @property {string} small_capsule
+   * @property {string} header
+   * @property {string} package_header
+   * @property {string} page_background
+   * @property {string} hero_capsule
+   * @property {string} hero_capsule_2x
+   * @property {string} library_capsule
+   * @property {string} library_capsule_2x
+   * @property {string} library_hero
+   * @property {string} library_hero_2x
+   * @property {string} community_icon
+   * @property {string} clan_avatar
+   */
+
+  /**
+   * Retrieves Steam Store items given app IDs. Wraps Steam API call and returns strong-typed results.
+   *
+   * @param {number|number[]} appIds A single Steam appid or an array of appids.
+   * @returns {Promise<SteamStoreItemsResponse|undefined>} Returns the Steam Store API response containing store_items, or undefined if appIds is not provided.
+   */
   static async getSteamStoreItems(appIds) {
     if (!appIds) {
       return;
@@ -8264,6 +8288,95 @@ export default class SteamUser {
 
 SteamUser.MAX_RETRY = 10;
 
+// Helper: Ensure URL has sessionid and language
+function ensureSessionIdAndLangInUrl(url, sessionId) {
+  const urlObj = new URL(url);
+  if (![...urlObj.searchParams.keys()].some((k) => k.toLowerCase() === "sessionid")) {
+    urlObj.searchParams.append("sessionid", sessionId);
+  }
+  if (![...urlObj.searchParams.keys()].some((k) => k.toLowerCase() === "l")) {
+    urlObj.searchParams.append("l", "english");
+  }
+  return urlObj.toString();
+}
+
+// Pure HTML error parser
+function parseSteamHtmlError(html, originalURL, steamId) {
+  if (!html || typeof html !== "string") {
+    return;
+  }
+  const $ = cheerio.load(html.replace(/[\t\n\r]/gi, "").trim());
+  const title = $("head > title").text().trim();
+  const errorMsg = $("#error_msg").text().trim();
+  const headline = $("#headline").text().trim();
+  if (title && SteamErrorTitle.includes(title)) {
+    return new ResponseError({ message: errorMsg || "Steam Community :: Error", steamId, originalURL });
+  } else if (title === "Error" && headline === "Something Went Wrong") {
+    return new ResponseError({ message: headline, detail: $("#message").text().trim(), steamId, originalURL });
+  }
+}
+
+function normalizeParams(params, sessionId) {
+  if (typeof params === "string") {
+    params = { url: params };
+  }
+
+  if (!params.url.startsWith("http")) {
+    params.url = _.trimEnd(SteamcommunityURL, "/") + "/" + _.trimStart(params.url, "/");
+  }
+  params.originalURL = params.url;
+  params.url = ensureSessionIdAndLangInUrl(params.url, sessionId);
+
+  if (!(params.headers instanceof Header)) {
+    params.headers = new Header(params.headers);
+  }
+
+  params.headers.set(defaultHeaders());
+
+  if (params.ajax) {
+    params.headers.set(ajaxHeaders());
+    delete params.ajax;
+  }
+
+  if (!params.headers.get("referer")) {
+    const urlObj = new URL(params.url);
+    const referer = urlObj.protocol && urlObj.host ? `${urlObj.protocol}//${urlObj.host}` : SteamcommunityURL;
+    params.headers.set("referer", referer);
+  }
+
+  params.method = (params.method || "GET").toUpperCase();
+  params.timeout = params.timeout || 2 * 60000;
+  params.isRedirect = typeof params.isRedirect === "boolean" ? params.isRedirect : true;
+
+  return params;
+}
+
+function defaultHeaders() {
+  return {
+    accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "no-cache",
+    pragma: "no-cache",
+    "sec-ch-ua": '"Not A(Brand";v="99", "Google Chrome";v="121", "Chromium";v="121"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+  };
+}
+
+function ajaxHeaders() {
+  return {
+    "X-KL-Ajax-Request": "Ajax_Request",
+    "X-Prototype-Version": "1.7",
+    "X-Requested-With": "XMLHttpRequest",
+  };
+}
+
 export class ResponseError {
   constructor({ loginFirst, message, steamId, originalURL }) {
     this.loginFirst = loginFirst;
@@ -8280,6 +8393,7 @@ export class ResponseError {
     return false;
   }
 }
+
 export class ResponseSuccess {
   constructor(response) {
     this.response = response;

package/package.json

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