3.18.0

Adding ability to edit an annoucement.

classes/CConfirmation.js

@@ -0,0 +1,20 @@
+module.exports = CConfirmation;
+
+function CConfirmation(community, data) {
+	this._community = community;
+
+	this.id = data.id;
+	this.key = data.key;
+	this.title = data.title;
+	this.receiving = data.receiving;
+	this.time = data.time;
+	this.icon = data.icon;
+}
+
+CConfirmation.prototype.getOfferID = function(time, key, callback) {
+	this._community.getConfirmationOfferID(this.id, time, key, callback);
+};
+
+CConfirmation.prototype.respond = function(time, key, accept, callback) {
+	this._community.respondToConfirmation(this.id, this.key, time, key, accept, callback);
+};

classes/CEconItem.js

@@ -0,0 +1,66 @@
+module.exports = CEconItem;
+
+function CEconItem(item, descriptions, contextID) {
+	var thing;
+	for(thing in item) {
+		if(item.hasOwnProperty(thing)) {
+			this[thing] = item[thing];
+		}
+	}
+
+	this.assetid = this.id = (this.id || this.assetid);
+	this.instanceid = this.instanceid || '0';
+	this.amount = parseInt(this.amount, 10);
+	this.contextid = this.contextid || contextID.toString();
+
+	// Merge the description
+	if(descriptions) {
+		var description = descriptions[this.classid + '_' + this.instanceid];
+		if(description) {
+			for(thing in description) {
+				if(description.hasOwnProperty(thing)) {
+					this[thing] = description[thing];
+				}
+			}
+		}
+	}
+
+	this.is_currency = !!this.is_currency;
+	this.tradable = !!this.tradable;
+	this.marketable = !!this.marketable;
+	this.commodity = !!this.commodity;
+	this.market_tradable_restriction = (this.market_tradable_restriction ? parseInt(this.market_tradable_restriction, 10) : 0);
+	this.market_marketable_restriction = (this.market_marketable_restriction ? parseInt(this.market_marketable_restriction, 10) : 0);
+	this.fraudwarnings = this.fraudwarnings || [];
+	this.descriptions = this.descriptions || [];
+
+	if(this.owner && JSON.stringify(this.owner) == '{}') {
+		this.owner = null;
+	}
+}
+
+CEconItem.prototype.getImageURL = function() {
+	return "https://steamcommunity-a.akamaihd.net/economy/image/" + this.icon_url + "/";
+};
+
+CEconItem.prototype.getLargeImageURL = function() {
+	if(!this.icon_url_large) {
+		return this.getImageURL();
+	}
+
+	return "https://steamcommunity-a.akamaihd.net/economy/image/" + this.icon_url_large + "/";
+};
+
+CEconItem.prototype.getTag = function(category) {
+	if(!this.tags) {
+		return null;
+	}
+
+	for(var i = 0; i < this.tags.length; i++) {
+		if(this.tags[i].category == category) {
+			return this.tags[i];
+		}
+	}
+
+	return null;
+};

classes/CMarketSearchResult.js

@@ -69,7 +69,7 @@ function performSearch(request, qs, results, callback) {
 			callback(null, results);
 		} else {
 			qs.start += body.pagesize;
-			performSearch(request, qs, results, callback);
+			performSearch.call(self, request, qs, results, callback);
 		}
 	});
 }

classes/CSteamGroup.js

@@ -64,7 +64,7 @@ CSteamGroup.prototype.getMembers = function(addresses, callback) {
 		callback = addresses;
 		addresses = null;
 	}
-
+	
 	this._community.getGroupMembers(this.steamID, callback, null, null, addresses, 0);
 };
 
@@ -76,10 +76,22 @@ CSteamGroup.prototype.leave = function(callback) {
 	this._community.leaveGroup(this.steamID, callback);
 };
 
+CSteamGroup.prototype.getAllAnnouncements = function(time, callback) {
+	this._community.getAllGroupAnnouncements(this.steamID, time, callback);
+};
+
 CSteamGroup.prototype.postAnnouncement = function(headline, content, callback) {
 	this._community.postGroupAnnouncement(this.steamID, headline, content, callback);
 };
 
+CSteamGroup.prototype.editAnnouncement = function(annoucementID, headline, content, callback) {
+	this._community.editGroupAnnouncement(this.steamID, annoucementID, headline, content, callback)
+};
+
+CSteamGroup.prototype.deleteAnnouncement = function(annoucementID, headline, content, callback) {
+	this._community.deleteGroupAnnouncement(this.steamID, annoucementID, headline, content, callback)
+};
+
 CSteamGroup.prototype.scheduleEvent = function(name, type, description, time, server, callback) {
 	this._community.scheduleGroupEvent(this.steamID, name, type, description, time, server, callback);
 };

classes/CSteamUser.js

@@ -40,6 +40,11 @@ SteamCommunity.prototype.getSteamUser = function(id, callback) {
 					customurl = match[1];
 				}
 			}
+
+			if(!result.profile.steamID64) {
+				callback(new Error("No valid response"));
+				return;
+			}
 			
 			callback(null, new CSteamUser(self, result.profile, customurl));
 		});
@@ -50,22 +55,26 @@ function CSteamUser(community, userData, customurl) {
 	this._community = community;
 	
 	this.steamID = new SteamID(userData.steamID64[0]);
-	this.name = userData.steamID[0];
-	this.onlineState = userData.onlineState[0];
-	this.stateMessage = userData.stateMessage[0];
-	this.privacyState = userData.privacyState[0];
-	this.visibilityState = userData.visibilityState[0];
-	this.avatarHash = userData.avatarIcon[0].match(/([0-9a-f]+)\.[a-z]+$/)[1];
-	this.vacBanned = !!userData.vacBanned[0];
-	this.tradeBanState = userData.tradeBanState[0];
-	this.isLimitedAccount = !!userData.isLimitedAccount[0];
-	this.customURL = userData.customURL ? userData.customURL[0] : customurl;
+	this.name = processItem('steamID');
+	this.onlineState = processItem('onlineState');
+	this.stateMessage = processItem('stateMessage');
+	this.privacyState = processItem('privacyState', 'uncreated');
+	this.visibilityState = processItem('visibilityState');
+	this.avatarHash = processItem('avatarIcon', '').match(/([0-9a-f]+)\.[a-z]+$/);
+	if(this.avatarHash) {
+		this.avatarHash = this.avatarHash[1];
+	}
+
+	this.vacBanned = processItem('vacBanned', false) == 1;
+	this.tradeBanState = processItem('tradeBanState', 'None');
+	this.isLimitedAccount = processItem('isLimitedAccount') == 1;
+	this.customURL = processItem('customURL', customurl);
 	
 	if(this.visibilityState == 3) {
-		this.memberSince = new Date(userData.memberSince[0].replace(/(\d{1,2})(st|nd|th)/, "$1"));
-		this.location = userData.location[0] || null;
-		this.realName = userData.realname[0] || null;
-		this.summary = userData.summary[0] || null;
+		this.memberSince = new Date(processItem('memberSince', '0').replace(/(\d{1,2})(st|nd|th)/, "$1"));
+		this.location = processItem('location');
+		this.realName = processItem('realname');
+		this.summary = processItem('summary');
 	} else {
 		this.memberSince = null;
 		this.location = null;
@@ -88,6 +97,14 @@ function CSteamUser(community, userData, customurl) {
 			return new SteamID(group.groupID64[0]);
 		});
 	}
+
+	function processItem(name, defaultVal) {
+		if(!userData[name]) {
+			return defaultVal;
+		}
+
+		return userData[name][0];
+	}
 }
 
 CSteamUser.getAvatarURL = function(hash, size, protocol) {
@@ -134,3 +151,11 @@ CSteamUser.prototype.comment = function(message, callback) {
 CSteamUser.prototype.inviteToGroup = function(groupID, callback) {
 	this._community.inviteUserToGroup(this.steamID, groupID, callback);
 };
+
+CSteamUser.prototype.getInventoryContexts = function(callback) {
+	this._community.getUserInventoryContexts(this.steamID, callback);
+};
+
+CSteamUser.prototype.getInventory = function(appID, contextID, tradableOnly, callback) {
+	this._community.getUserInventory(this.steamID, appID, contextID, tradableOnly, callback);
+};

components/chat.js

@@ -40,17 +40,9 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 	this.chatState = SteamCommunity.ChatState.LoggingOn;
 	
 	var self = this;
-	this.request("https://steamcommunity.com/chat", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			self.emit('debug', 'Error requesting chat WebAPI token: ' + (err ? err.message : "HTTP error " + response.statusCode));
-			self.chatState = SteamCommunity.ChatState.LogOnFailed;
-			setTimeout(self.chatLogon.bind(self), 5000);
-			return;
-		}
-		
-		var match = body.match(/[0-9a-f]{32}/);
-		if(!match) {
-			self.emit('debug', 'Couldn\'t find a WebAPI chat token in the response.');
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			self.emit('debug', "Cannot get oauth token: " + err.message);
 			self.chatState = SteamCommunity.ChatState.LogOnFailed;
 			setTimeout(self.chatLogon.bind(self), 5000);
 			return;
@@ -60,7 +52,7 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 			"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Logon/v1",
 			"form": {
 				"ui_mode": uiMode,
-				"access_token": match[0]
+				"access_token": token
 			},
 			"json": true
 		}, function(err, response, body) {
@@ -81,7 +73,7 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 			self._chat = {
 				"umqid": body.umqid,
 				"message": body.message,
-				"accessToken": match[0],
+				"accessToken": token,
 				"interval": interval
 			};
 			
@@ -109,7 +101,8 @@ SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback)
 	}
 	
 	type = type || 'saytext';
-	
+
+	var self = this;
 	this.request.post({
 		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Message/v1",
 		"form": {

components/confirmations.js

@@ -0,0 +1,335 @@
+var SteamCommunity = require('../index.js');
+var Cheerio = require('cheerio');
+var SteamTotp = require('steam-totp');
+var Async = require('async');
+
+var CConfirmation = require('../classes/CConfirmation.js');
+
+/**
+ * Get a list of your account's currently outstanding confirmations.
+ * @param {int} time - The unix timestamp with which the following key was generated
+ * @param {string} key - The confirmation key that was generated using the preceeding time and the tag "conf" (this key can be reused)
+ * @param {SteamCommunity~getConfirmations} callback - Called when the list of confirmations is received
+ */
+SteamCommunity.prototype.getConfirmations = function(time, key, callback) {
+	var self = this;
+
+	request(this, "conf", key, time, "conf", null, false, function(err, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		var $ = Cheerio.load(body);
+		var empty = $('#mobileconf_empty');
+		if(empty.length > 0) {
+			if(!$(empty).hasClass('mobileconf_done')) {
+				// An error occurred
+				callback(new Error(empty.find('div:nth-of-type(2)').text()));
+			} else {
+				callback(null, []);
+			}
+
+			return;
+		}
+
+		// We have something to confirm
+		var confirmations = $('#mobileconf_list');
+		if(!confirmations) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		var confs = [];
+		Array.prototype.forEach.call(confirmations.find('.mobileconf_list_entry'), function(conf) {
+			conf = $(conf);
+
+			var img = conf.find('.mobileconf_list_entry_icon img');
+			confs.push(new CConfirmation(self, {
+				"id": conf.data('confid'),
+				"key": conf.data('key'),
+				"title": conf.find('.mobileconf_list_entry_description>div:nth-of-type(1)').text().trim(),
+				"receiving": conf.find('.mobileconf_list_entry_description>div:nth-of-type(2)').text().trim(),
+				"time": conf.find('.mobileconf_list_entry_description>div:nth-of-type(3)').text().trim(),
+				"icon": img.length < 1 ? '' : $(img).attr('src')
+			}));
+		});
+
+		callback(null, confs);
+	});
+};
+
+/**
+ * @callback SteamCommunity~getConfirmations
+ * @param {Error|null} err - An Error object on failure, or null on success
+ * @param {CConfirmation[]} confirmations - An array of CConfirmation objects
+ */
+
+/**
+ * Get the trade offer ID associated with a particular confirmation
+ * @param {int} confID - The ID of the confirmation in question
+ * @param {int} time - The unix timestamp with which the following key was generated
+ * @param {string} key - The confirmation key that was generated using the preceeding time and the tag "details" (this key can be reused)
+ * @param {SteamCommunity~getConfirmationOfferID} callback
+ */
+SteamCommunity.prototype.getConfirmationOfferID = function(confID, time, key, callback) {
+	request(this, "details/" + confID, key, time, "details", null, true, function(err, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		if(!body.success) {
+			callback(new Error("Cannot load confirmation details"));
+			return;
+		}
+
+		var $ = Cheerio.load(body.html);
+		var offer = $('.tradeoffer');
+		if(offer.length < 1) {
+			callback(null, null);
+			return;
+		}
+
+		callback(null, offer.attr('id').split('_')[1]);
+	});
+};
+
+/**
+ * @callback SteamCommunity~getConfirmationOfferID
+ * @param {Error|null} err - An Error object on failure, or null on success
+ * @param {string} offerID - The trade offer ID associated with the specified confirmation, or null if not for an offer
+ */
+
+/**
+ * Confirm or cancel a given confirmation.
+ * @param {int} confID - The ID of the confirmation in question
+ * @param {string} confKey - The confirmation key associated with the confirmation in question (not a TOTP key, the `key` property of CConfirmation)
+ * @param {int} time - The unix timestamp with which the following key was generated
+ * @param {string} key - The confirmation key that was generated using the preceeding time and the tag "allow" (if accepting) or "cancel" (if not accepting)
+ * @param {boolean} accept - true if you want to accept the confirmation, false if you want to cancel it
+ * @param {SteamCommunity~genericErrorCallback} callback - Called when the request is complete
+ */
+SteamCommunity.prototype.respondToConfirmation = function(confID, confKey, time, key, accept, callback) {
+	request(this, "ajaxop", key, time, accept ? "allow" : "cancel", {
+		"op": accept ? "allow" : "cancel",
+		"cid": confID,
+		"ck": confKey
+	}, true, function(err, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		if(body.success) {
+			callback(null);
+			return;
+		}
+
+		if(body.message) {
+			callback(new Error(body.message));
+			return;
+		}
+
+		callback(new Error("Could not act on confirmation"));
+	});
+};
+
+function request(community, url, key, time, tag, params, json, callback) {
+	params = params || {};
+	params.p = "android:" + require('crypto').randomBytes(16).toString('hex');
+	params.a = community.steamID.getSteamID64();
+	params.k = key;
+	params.t = time;
+	params.m = "android";
+	params.tag = tag;
+
+	community.request.get({
+		"uri": "https://steamcommunity.com/mobileconf/" + url,
+		"qs": params,
+		"json": !!json
+	}, function(err, response, body) {
+		if(community._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		callback(null, body);
+	});
+}
+
+// Confirmation checker
+
+/**
+ * Start automatically polling our confirmations for new ones. The `confKeyNeeded` event will be emitted when we need a confirmation key, or `newConfirmation` when we get a new confirmation
+ * @param {int} pollInterval - The interval, in milliseconds, at which we will poll for confirmations. This shouldn't be any less than 10,000 probably.
+ * @param {Buffer|string|null} [identitySecret=null] - Your identity_secret. If passed, all confirmations will be automatically accepted and nothing will be emitted.
+ */
+SteamCommunity.prototype.startConfirmationChecker = function(pollInterval, identitySecret) {
+	this._confirmationPollInterval = pollInterval;
+	this._knownConfirmations = this._knownConfirmations || {};
+	this._confirmationKeys = this._confirmationKeys || {};
+	this._identitySecret = identitySecret;
+
+	if(this._confirmationTimer) {
+		clearTimeout(this._confirmationTimer);
+	}
+
+	setTimeout(this.checkConfirmations.bind(this), 500);
+};
+
+/**
+ * Stop automatically polling our confirmations.
+ */
+SteamCommunity.prototype.stopConfirmationChecker = function() {
+	if(this._confirmationPollInterval) {
+		delete this._confirmationPollInterval;
+	}
+
+	if(this._identitySecret) {
+		delete this._identitySecret;
+	}
+
+	if(this._confirmationTimer) {
+		clearTimeout(this._confirmationTimer);
+		delete this._confirmationTimer;
+	}
+};
+
+/**
+ * Run the confirmation checker right now instead of waiting for the next poll.
+ * Useful to call right after you send/accept an offer that needs confirmation.
+ */
+SteamCommunity.prototype.checkConfirmations = function() {
+	if(this._confirmationTimer) {
+		clearTimeout(this._confirmationTimer);
+		delete this._confirmationTimer;
+	}
+
+	var self = this;
+	if(!this._confirmationQueue) {
+		this._confirmationQueue = Async.queue(function(conf, callback) {
+			// Worker to process new confirmations
+			if(self._identitySecret) {
+				// We should accept this
+				self.emit('debug', "Accepting confirmation #" + conf.id);
+				var time = Math.floor(Date.now() / 1000);
+				conf.respond(time, SteamTotp.getConfirmationKey(self._identitySecret, time, "allow"), true, function() {
+					// If there was an error and it wasn't actually accepted, we'll pick it up again
+					delete self._knownConfirmations[conf.id];
+					setTimeout(callback, 1000); // Call the callback in 1 second, to make sure the time changes
+				});
+			} else {
+				self.emit('newConfirmation', conf);
+				setTimeout(callback, 1000); // Call the callback in 1 second, to make sure the time changes
+			}
+		}, 1);
+	}
+
+	this.emit('debug', 'Checking confirmations');
+
+	this._confirmationCheckerGetKey('conf', function(err, key) {
+		if(err) {
+			resetTimer();
+			return;
+		}
+
+		self.getConfirmations(key.time, key.key, function(err, confirmations) {
+			if(err) {
+				resetTimer();
+				return;
+			}
+
+			var known = self._knownConfirmations;
+
+			var newOnes = confirmations.filter(function(conf) {
+				return !known[conf.id];
+			});
+
+			if(newOnes.length < 1) {
+				resetTimer();
+				return; // No new ones
+			}
+
+			// We have new confirmations! Grab a key to get details.
+			self._confirmationCheckerGetKey('details', function(err, key) {
+				newOnes.forEach(function(conf) {
+					self._knownConfirmations[conf.id] = conf; // Add it to our list of known confirmations
+
+					if(err) {
+						self._confirmationQueue.push(conf);
+					} else {
+						// Get its offer ID, if we can
+						conf.getOfferID(key.time, key.key, function(err, offerID) {
+							conf.offerID = offerID ? offerID : null;
+							self._confirmationQueue.push(conf);
+						});
+					}
+				});
+
+				resetTimer();
+			});
+		});
+	});
+
+	function resetTimer() {
+		if(self._confirmationPollInterval) {
+			self._confirmationTimer = setTimeout(self.checkConfirmations.bind(self), self._confirmationPollInterval);
+		}
+	}
+
+	function handleNewConfirmation(conf, handleNumber) {
+		self._knownConfirmations[conf.id] = conf;
+
+		// Delay them by 1 second per new confirmation that we see, so that keys won't be the same.
+		setTimeout(function() {
+			if(self._identitySecret) {
+				self.emit('debug', 'Accepting confirmation ' + conf.id);
+				var time = Math.floor(Date.now() / 1000);
+				conf.respond(time, SteamTotp.getConfirmationKey(self._identitySecret, time, "allow"), true, function() {
+					delete self._knownConfirmations[conf.id];
+				});
+			} else {
+				self.emit('newConfirmation', conf);
+			}
+		}, handleNumber * 1000);
+	}
+};
+
+SteamCommunity.prototype._confirmationCheckerGetKey = function(tag, callback) {
+	if(this._identitySecret) {
+		if(tag == 'details') {
+			// We don't care about details
+			callback(new Error("Disabled"));
+			return;
+		}
+
+		var time = Math.floor(Date.now() / 1000);
+		callback(null, {"time": time, "key": SteamTotp.getConfirmationKey(this._identitySecret, time, tag)});
+		return;
+	}
+
+	var existing = this._confirmationKeys[tag];
+	var reusable = ['conf', 'details'];
+
+	// See if we already have a key that we can reuse.
+	if(reusable.indexOf(tag) != -1 && existing && (Date.now() - (existing.time * 1000) < (1000 * 60 * 5))) {
+		callback(null, existing);
+		return;
+	}
+
+	// We need a fresh one
+	var self = this;
+	this.emit('confKeyNeeded', tag, function(err, time, key) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		self._confirmationKeys[tag] = {"time": time, "key": key};
+		callback(null, {"time": time, "key": key});
+	});
+};

components/groups.js

@@ -125,6 +125,56 @@ SteamCommunity.prototype.leaveGroup = function(gid, callback) {
 	});
 };
 
+SteamCommunity.prototype.getAllGroupAnnouncements = function(gid, time, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof time === 'function') {
+		callback = time;
+		time = new Date(0); // The beginnig of time...
+	}
+
+	var self = this;
+	this.request({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/rss/" 
+	}, function(err, response, body) {
+
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		xml2js.parseString(body, function(err, results) {
+			if(err) {
+				return callback(err);
+			}
+
+			if(!results.rss.channel[0].item) {
+				return callback(null, []);
+			}
+
+			var announcements = results.rss.channel[0].item.map(function(announcement) {
+				var splitLink = announcement.link[0].split('/');
+				return {
+					headline: announcement.title[0],
+					content:  announcement.description[0],
+					date:     new Date(announcement.pubDate[0]),
+					author:   announcement.author[0],
+					aid:      splitLink[splitLink.length - 1]
+				}
+			}).filter(function(announcement) {
+				return (announcement.date > time);
+			});
+
+			return callback(null, announcements);
+		});
+	});
+}
+
 SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content, callback) {
 	if(typeof gid === 'string') {
 		gid = new SteamID(gid);
@@ -137,15 +187,82 @@ SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content
 			"sessionID": this.getSessionID(),
 			"action": "post",
 			"headline": headline,
-			"body": content
+			"body": content,
+			"languages[0][headline]": headline,
+			"languages[0][body]": content
 		}
 	}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	})
+};
+
+SteamCommunity.prototype.editGroupAnnouncement = function(gid, aid, headline, content, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+
+	var submitData = {
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"gid": aid,
+			"action": "update",
+			"headline": headline,
+			"body": content,
+			"languages[0][headline]": headline,
+			"languages[0][body]": content,
+			"languages[0][updated]": 1
+		}
+	}
+
+	this.request.post(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	})
+};
+
+SteamCommunity.prototype.deleteGroupAnnouncement = function(gid, aid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+
+	var submitData = {
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements/delete/" + aid + "?sessionID=" + this.getSessionID(),
+	}
+
+	this.request.get(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 
@@ -203,7 +320,7 @@ SteamCommunity.prototype.scheduleGroupEvent = function(gid, name, type, descript
 
 	var self = this;
 	this.request.post({
-		"uri": "https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit",
+		"uri": "https://steamcommunity.com/gid/" + gid.toString() + "/eventEdit",
 		"form": form
 	}, function(err, response, body) {
 		if(!callback) {

components/inventoryhistory.js

@@ -0,0 +1,143 @@
+var SteamCommunity = require('../index.js');
+var CEconItem = require('../classes/CEconItem.js');
+var SteamID = require('steamid');
+var request = require('request');
+var Cheerio = require('cheerio');
+var Async = require('async');
+
+SteamCommunity.prototype.getInventoryHistory = function(options, callback) {
+	if(typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+	
+	options.page = options.page || 1;
+	
+	this.request("https://steamcommunity.com/my/inventoryhistory?l=english&p=" + options.page, function(err, response, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+		
+		var output = {};
+		var vanityURLs = [];
+		
+		var $ = Cheerio.load(body);
+		var html = $('.inventory_history_pagingrow').html();
+		if(!html) {
+			callback("Malformed page: no paging row found");
+			return;
+		}
+		
+		var match = html.match(/(\d+) - (\d+) of (\d+) History Items/);
+		
+		output.first = parseInt(match[1], 10);
+		output.last = parseInt(match[2], 10);
+		output.totalTrades = parseInt(match[3], 10);
+		
+		// Load the inventory item data
+		var match2 = body.match(/var g_rgHistoryInventory = (.*);/);
+		if(!match2) {
+			callback(new Error("Malformed page: no trade found"));
+			return;
+		}
+		var historyInventory = JSON.parse(match2[1]);
+		
+		output.trades = [];
+		var trades = $('.tradehistoryrow');
+		
+		var item, trade, profileLink, items, j, econItem, timeMatch, time;
+		for(var i = 0; i < trades.length; i++) {
+			item = $(trades[i]);
+			trade = {};
+
+			trade.onHold = !!item.find('span:nth-of-type(2)').text().match(/Trade on Hold/i);
+			
+			timeMatch = item.find('.tradehistory_timestamp').html().match(/(\d+):(\d+)(am|pm)/);
+			if(timeMatch[1] == 12 && timeMatch[3] == 'am') {
+				timeMatch[1] = 0;
+			}
+			
+			if(timeMatch[1] < 12 && timeMatch[3] == 'pm') {
+				timeMatch[1] = parseInt(timeMatch[1], 10) + 12;
+			}
+			
+			time = (timeMatch[1] < 10 ? '0' : '') + timeMatch[1] + ':' + timeMatch[2] + ':00';
+			
+			trade.date = new Date(item.find('.tradehistory_date').html() + ' ' + time);
+			trade.partnerName = item.find('.tradehistory_event_description a').html();
+			trade.partnerSteamID = null;
+			trade.partnerVanityURL = null;
+			trade.itemsReceived = [];
+			trade.itemsGiven = [];
+			
+			profileLink = item.find('.tradehistory_event_description a').attr('href');
+			if(profileLink.indexOf('/profiles/') != -1) {
+				trade.partnerSteamID = new SteamID(profileLink.match(/(\d+)$/)[1]);
+			} else {
+				trade.partnerVanityURL = profileLink.match(/\/([^\/]+)$/)[1];
+				if(options.resolveVanityURLs && vanityURLs.indexOf(trade.partnerVanityURL) == -1) {
+					vanityURLs.push(trade.partnerVanityURL);
+				}
+			}
+			
+			items = item.find('.history_item');
+			for(j = 0; j < items.length; j++) {
+				match = body.match(new RegExp("HistoryPageCreateItemHover\\( '" + $(items[j]).attr('id') + "', (\\d+), '(\\d+)', '(\\d+|class_\\d+_instance_\\d+|class_\\d+)', '(\\d+)' \\);"));
+				econItem = historyInventory[match[1]][match[2]][match[3]];
+				
+				if($(items[j]).attr('id').indexOf('received') != -1) {
+					trade.itemsReceived.push(new CEconItem(econItem));
+				} else {
+					trade.itemsGiven.push(new CEconItem(econItem));
+				}
+			}
+			
+			output.trades.push(trade);
+		}
+		
+		if(options.resolveVanityURLs) {
+			Async.map(vanityURLs, resolveVanityURL, function(err, results) {
+				if(err) {
+					callback(err);
+					return;
+				}
+				
+				for(i = 0; i < output.trades.length; i++) {
+					if(output.trades[i].partnerSteamID || !output.trades[i].partnerVanityURL) {
+						continue;
+					}
+					
+					// Find the vanity URL
+					for(j = 0; j < results.length; j++) {
+						if(results[j].vanityURL == output.trades[i].partnerVanityURL) {
+							output.trades[i].partnerSteamID = new SteamID(results[j].steamID);
+							break;
+						}
+					}
+				}
+				
+				callback(null, output);
+			});
+		} else {
+			callback(null, output);
+		}
+	});
+};
+
+function resolveVanityURL(vanityURL, callback) {
+	request("https://steamcommunity.com/id/" + vanityURL + "/?xml=1", function(err, response, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+		
+		var match = body.match(/<steamID64>(\d+)<\/steamID64>/);
+		if(!match || !match[1]) {
+			callback(new Error("Couldn't find Steam ID"));
+			return;
+		}
+		
+		callback(null, {"vanityURL": vanityURL, "steamID": match[1]});
+	});
+}

components/profile.js

@@ -101,10 +101,10 @@ SteamCommunity.prototype.editProfile = function(settings, callback) {
 					break;
 				
 				case 'primaryGroup':
-					if(typeof settings[i] === 'object' && settings[i].accountid) {
-						values.primary_group_steamid = settings[i].accountid;
+					if(typeof settings[i] === 'object' && settings[i].getSteamID64) {
+						values.primary_group_steamid = settings[i].getSteamID64();
 					} else {
-						values.primary_group_steamid = new SteamID(settings[i]).accountid;
+						values.primary_group_steamid = new SteamID(settings[i]).getSteamID64();
 					}
 					
 					break;
@@ -191,9 +191,14 @@ SteamCommunity.prototype.profileSettings = function(settings, callback) {
 					values.inventoryGiftPrivacy = settings[i] ? 1 : 0;
 					break;
 				
-				case 'emailConfirmation':
+				case 'emailConfirmation': // deprecated
+				case 'tradeConfirmation':
 					values.tradeConfirmationSetting = settings[i] ? 1 : 0;
 					break;
+
+				case 'marketConfirmation':
+					values.marketConfirmationSetting = settings[i] ? 1 : 0;
+					break;
 			}
 		}
 		

components/twofactor.js

@@ -0,0 +1,159 @@
+var SteamTotp = require('steam-totp');
+var SteamCommunity = require('../index.js');
+
+var ETwoFactorTokenType = {
+	"None": 0,                  // No token-based two-factor authentication
+	"ValveMobileApp": 1,        // Tokens generated using Valve's special charset (5 digits, alphanumeric)
+	"ThirdParty": 2             // Tokens generated using literally everyone else's standard charset (6 digits, numeric). This is disabled.
+};
+
+SteamCommunity.prototype.enableTwoFactor = function(callback) {
+	var self = this;
+
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		// Create a random device ID hash
+		var hash = require('crypto').createHash('sha1');
+		hash.update(self.steamID.getSteamID64());
+		hash = hash.digest('hex');
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/AddAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"authenticator_time": Math.floor(Date.now() / 1000),
+				"authenticator_type": ETwoFactorTokenType.ValveMobileApp,
+				"device_identifier": 'android:' + hash,
+				"sms_phone_id": "1"
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			if(body.response.status != 1) {
+				var error = new Error("Error " + body.response.status);
+				error.eresult = body.response.status;
+				callback(error);
+				return;
+			}
+
+			callback(null, body.response);
+		});
+	});
+};
+
+SteamCommunity.prototype.finalizeTwoFactor = function(secret, activationCode, callback) {
+	var attemptsLeft = 30;
+	var diff = 0;
+
+	var self = this;
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		finalize(token);
+	});
+
+	function finalize(token) {
+		var code = SteamTotp.generateAuthCode(secret, diff);
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/FinalizeAddAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"authenticator_code": code,
+				"authenticator_time": Math.floor(Date.now() / 1000),
+				"activation_code": activationCode
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			body = body.response;
+
+			if(body.server_time) {
+				diff = body.server_time - Math.floor(Date.now() / 1000);
+			}
+
+			if(body.status == 89) {
+				callback(new Error("Invalid activation code"));
+			} else if(body.want_more) {
+				attemptsLeft--;
+				diff += 30;
+
+				finalize(token);
+			} else if(!body.success) {
+				callback(new Error("Error " + body.status));
+			} else {
+				callback(null);
+			}
+		});
+	}
+};
+
+SteamCommunity.prototype.disableTwoFactor = function(revocationCode, callback) {
+	var self = this;
+
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/RemoveAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"revocation_code": revocationCode,
+				"steamguard_scheme": 1
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			if(!body.response.success) {
+				callback(new Error("Request failed"));
+				return;
+			}
+
+			if(body.response.status == 1) {
+				callback(null);
+				return;
+			}
+
+			var error = new Error("Cannot remove authenticator (" + body.response.status + ")");
+			error.eresult = body.response.status;
+			callback(error);
+		});
+	});
+};

components/users.js

@@ -1,5 +1,6 @@
 var SteamCommunity = require('../index.js');
 var SteamID = require('steamid');
+var CEconItem = require('../classes/CEconItem.js');
 
 SteamCommunity.prototype.addFriend = function(userID, callback) {
 	if(typeof userID === 'string') {
@@ -155,7 +156,7 @@ SteamCommunity.prototype.postUserComment = function(userID, message, callback) {
 
 		if(body.success) {
 			callback(null);
-		} else if(bpdy.error) {
+		} else if(body.error) {
 			callback(new Error(body.error));
 		} else {
 			callback(new Error("Unknown error"));
@@ -197,3 +198,101 @@ SteamCommunity.prototype.inviteUserToGroup = function(userID, groupID, callback)
 		}
 	});
 };
+
+SteamCommunity.prototype.getUserInventoryContexts = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	if(typeof userID === 'function') {
+		callback = userID;
+		userID = this.steamID;
+	}
+
+	if(!userID) {
+		callback(new Error("No SteamID specified and not logged in"));
+		return;
+	}
+
+	var self = this;
+	this.request("https://steamcommunity.com/profiles/" + userID.getSteamID64() + "/inventory/", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		var match = body.match(/var g_rgAppContextData = ([^\n]+);\r?\n/);
+		if(!match) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		var data;
+		try {
+			data = JSON.parse(match[1]);
+		} catch(e) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		callback(null, data);
+	});
+};
+
+SteamCommunity.prototype.getUserInventory = function(userID, appID, contextID, tradableOnly, callback) {
+	var self = this;
+
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var endpoint = "/profiles/" + userID.getSteamID64();
+	get([], []);
+
+	function get(inventory, currency, start) {
+		self.request({
+			"uri": "https://steamcommunity.com" + endpoint + "/inventory/json/" + appID + "/" + contextID,
+			"qs": {
+				"start": start,
+				"trading": tradableOnly ? 1 : undefined
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body || !body.success || !body.rgInventory || !body.rgDescriptions || !body.rgCurrency) {
+				callback(new Error(body.Error || "Malformed response"));
+				return;
+			}
+
+			var i;
+			for(i in body.rgInventory) {
+				if(!body.rgInventory.hasOwnProperty(i)) {
+					continue;
+				}
+
+				inventory.push(new CEconItem(body.rgInventory[i], body.rgDescriptions, contextID));
+			}
+
+			for(i in body.rgCurrency) {
+				if(!body.rgCurrency.hasOwnProperty(i)) {
+					continue;
+				}
+
+				currency.push(new CEconItem(body.rgInventory[i], body.rgDescriptions, contextID));
+			}
+
+			if(body.more) {
+				var match = response.request.uri.href.match(/\/(profiles|id)\/([^\/]+)\//);
+				if(match) {
+					endpoint = "/" + match[1] + "/" + match[2];
+				}
+
+				get(inventory, currency, body.more_start);
+			} else {
+				callback(null, inventory, currency);
+			}
+		});
+	}
+};

components/webapi.js

@@ -0,0 +1,66 @@
+var SteamCommunity = require('../index.js');
+
+SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
+	var self = this;
+	this.request({
+		"uri": "https://steamcommunity.com/dev/apikey",
+		"followRedirect": false
+	}, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(body.match(/<h2>Access Denied<\/h2>/)) {
+			return callback(new Error("Access Denied"));
+		}
+
+		var match = body.match(/<p>Key: ([0-9A-F]+)<\/p>/);
+		if(match) {
+			// We already have an API key registered
+			callback(null, match[1]);
+		} else {
+			// We need to register a new API key
+			self.request.post('https://steamcommunity.com/dev/registerkey', {
+				"form": {
+					"domain": domain,
+					"agreeToTerms": "agreed",
+					"sessionid": self.getSessionID(),
+					"Submit": "Register"
+				}
+			}, function(err, response, body) {
+				if(self._checkHttpError(err, response, callback)) {
+					return;
+				}
+
+				self.getWebApiKey(domain, callback);
+			});
+		}
+	});
+};
+
+SteamCommunity.prototype.getWebApiOauthToken = function(callback) {
+	var self = this;
+
+	if( this.oAuthToken ) {
+		return callback( null, this.oAuthToken );
+	}
+
+	// Pull an oauth token from the webchat UI
+	this.request("https://steamcommunity.com/chat", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		var match = body.match(/"([0-9a-f]{32})"/);
+		if (!match) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		callback(null, match[1]);
+	});
+};

examples/edit-group-announcement.js

@@ -0,0 +1,109 @@
+var SteamCommunity = require('../index.js');
+var ReadLine = require('readline');
+var fs = require('fs');
+
+var community = new SteamCommunity();
+var rl = ReadLine.createInterface({
+	"input": process.stdin,
+	"output": process.stdout
+});
+
+rl.question("Username: ", function(accountName) {
+	rl.question("Password: ", function(password) {
+		doLogin(accountName, password);
+	});
+});
+
+function doLogin(accountName, password, authCode, twoFactorCode) {
+	community.login({
+		"accountName": accountName,
+		"password": password,
+		"authCode": authCode,
+		"twoFactorCode": twoFactorCode
+	}, function(err, sessionID, cookies, steamguard) {
+		if(err) {
+			if(err.message == 'SteamGuardMobile') {
+				rl.question("Steam Authenticator Code: ", function(code) {
+					doLogin(accountName, password, null, code);
+				});
+
+				return;
+			}
+
+			if(err.message == 'SteamGuard') {
+				console.log("An email has been sent to your address at " + err.emaildomain);
+				rl.question("Steam Guard Code: ", function(code) {
+					doLogin(accountName, password, code);
+				});
+
+				return;
+			}
+
+			console.log(err);
+			process.exit();
+			return;
+		}
+
+		console.log("Logged on!");
+
+		rl.question("Group ID: ", function(gid) {
+			community.getSteamGroup(gid, function(err, group) {
+				if (err) {
+					console.log(err);
+					process.exit(1);
+				}
+
+				group.getAllAnnouncements(function(err, announcements) {
+
+					if(announcements.length === 0) {
+						return console.log("This group has no announcements");
+					}
+
+					for (var i = announcements.length - 1; i >= 0; i--) {
+						console.log("[%s] %s %s: %s", announcements[i].date, announcements[i].aid, announcements[i].author, announcements[i].content);
+					};
+
+					rl.question("Would you like to delete delete or edit an annoucement? (Type edit/delete): ", function(choice) {
+						rl.question("Annoucement ID: ", function(aid) {
+							if(choice === 'edit') {
+								rl.question("New title: ", function(header) {
+									rl.question("New body: ", function(content) {
+										// EW THE PYRAMID!
+										// Try replace this with delete!
+										editAnnouncement(group, aid, header, content);
+									});
+								});
+							} else {
+								deleteAnnouncement(group, aid);
+							}
+						});
+					});
+				});
+			});
+		});
+	});
+}
+
+function editAnnouncement(group, aid, header, content) {
+	// Actual community method.
+	group.editAnnouncement(aid, header, content, function(error) {
+		if(!error) {
+			console.log("Annoucement edited!");
+		} else {
+			console.log("Unable to edit annoucement! %j", error);
+			process.exit(1);
+		}
+	});
+}
+
+function deleteAnnouncement(group, aid) {
+	// group.deleteAnnouncement(aid);
+	// Or
+	group.deleteAnnouncement(aid, function(err) {
+		if(!err) {
+			console.log("Deleted");
+		} else {
+			console.log("Error deleting announcement.");
+		}
+	})
+}

examples/enable_twofactor.js

@@ -0,0 +1,97 @@
+var SteamCommunity = require('../index.js');
+var ReadLine = require('readline');
+var fs = require('fs');
+
+var community = new SteamCommunity();
+var rl = ReadLine.createInterface({
+	"input": process.stdin,
+	"output": process.stdout
+});
+
+rl.question("Username: ", function(accountName) {
+	rl.question("Password: ", function(password) {
+		doLogin(accountName, password);
+	});
+});
+
+function doLogin(accountName, password, authCode) {
+	community.login({
+		"accountName": accountName,
+		"password": password,
+		"authCode": authCode
+	}, function(err, sessionID, cookies, steamguard) {
+		if(err) {
+			if(err.message == 'SteamGuardMobile') {
+				console.log("This account already has two-factor authentication enabled.");
+				process.exit();
+				return;
+			}
+
+			if(err.message == 'SteamGuard') {
+				console.log("An email has been sent to your address at " + err.emaildomain);
+				rl.question("Steam Guard Code: ", function(code) {
+					doLogin(accountName, password, code);
+				});
+
+				return;
+			}
+
+			console.log(err);
+			process.exit();
+			return;
+		}
+
+		console.log("Logged on!");
+		community.enableTwoFactor(function(err, response) {
+			if(err) {
+				if(err.eresult == 2) {
+					console.log("Error: Failed to enable two-factor authentication. Do you have a phone number attached to your account?");
+					process.exit();
+					return;
+				}
+
+				if(err.eresult == 84) {
+					console.log("Error: RateLimitExceeded. Try again later.");
+					process.exit();
+					return;
+				}
+
+				console.log(err);
+				process.exit();
+				return;
+			}
+
+			if(response.status != 1) {
+				console.log("Error: Status " + response.status);
+				process.exit();
+				return;
+			}
+
+			console.log("Writing secrets to twofactor_" + community.steamID.getSteamID64() + ".json");
+			console.log("Revocation code: " + response.revocation_code);
+			fs.writeFile("twofactor_" + community.steamID.getSteamID64() + ".json", JSON.stringify(response, null, "\t"));
+
+			promptActivationCode(response);
+		});
+	});
+}
+
+function promptActivationCode(response) {
+	rl.question("SMS Code: ", function(smsCode) {
+		community.finalizeTwoFactor(response.shared_secret, smsCode, function(err) {
+			if(err) {
+				if(err.message == "Invalid activation code") {
+					console.log(err);
+					promptActivationCode(response);
+					return;
+				}
+
+				console.log(err);
+			} else {
+				console.log("Two-factor authentication enabled!");
+			}
+
+			process.exit();
+		});
+	});
+}

index.js

@@ -3,24 +3,44 @@ var RSA = require('node-bignumber').Key;
 var hex2b64 = require('node-bignumber').hex2b64;
 var SteamID = require('steamid');
 
+const USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36";
+
 require('util').inherits(SteamCommunity, require('events').EventEmitter);
 
 module.exports = SteamCommunity;
 
 SteamCommunity.SteamID = SteamID;
 
-function SteamCommunity(localAddress) {
+function SteamCommunity(options) {
+	options = options || {};
+
 	this._jar = Request.jar();
 	this._captchaGid = -1;
 	this.chatState = SteamCommunity.ChatState.Offline;
 
-	var defaults = {"jar": this._jar, "timeout": 50000};
-	if(localAddress) {
-		defaults.localAddress = localAddress;
+	var defaults = {
+		"jar": this._jar,
+		"timeout": options.timeout || 50000,
+		"gzip": true,
+		"headers": {
+			"User-Agent": options.userAgent || USER_AGENT
+		}
+	};
+
+	if (typeof options == "string") {
+		options = {
+			localAddress: options
+		};
+	}
+	this._options = options;
+
+	if (options.localAddress) {
+		defaults.localAddress = options.localAddress;
 	}
 
-	this.request = Request.defaults(defaults);
-	
+	this.request = options.request || Request.defaults();
+	this.request = this.request.defaults(defaults);
+
 	// English
 	this._jar.setCookie(Request.cookie('Steam_Language=english'), 'https://steamcommunity.com');
 
@@ -35,8 +55,27 @@ SteamCommunity.prototype.login = function(details, callback) {
 	}
 	
 	var self = this;
-	this.request.post("https://steamcommunity.com/login/getrsakey/", {"form": {"username": details.accountName}}, function(err, response, body) {
+
+	// headers required to convince steam that we're logging in from a mobile device so that we can get the oAuth data
+	var mobileHeaders = {
+		"X-Requested-With": "com.valvesoftware.android.steam.community",
+		"Referer": "https://steamcommunity.com/mobilelogin?oauth_client_id=DE45CD61&oauth_scope=read_profile%20write_profile%20read_client%20write_client",
+		"User-Agent": "Mozilla/5.0 (Linux; U; Android 4.1.1; en-us; Google Nexus 4 - 4.1.1 - API 16 - 768x1280 Build/JRO03S) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30",
+		"Accept": "text/javascript, text/html, application/xml, text/xml, */*"
+	};
+
+	this._jar.setCookie(Request.cookie("mobileClientVersion=0 (2.1.3)"), "https://steamcommunity.com");
+	this._jar.setCookie(Request.cookie("mobileClient=android"), "https://steamcommunity.com");
+	
+	this.request.post("https://steamcommunity.com/login/getrsakey/", {
+		"form": {
+			"username": details.accountName
+		},
+		"headers": mobileHeaders
+	}, function(err, response, body) {
+		// Remove the mobile cookies
 		if(err) {
+			deleteMobileCookies();
 			callback(err);
 			return;
 		}
@@ -45,9 +84,16 @@ SteamCommunity.prototype.login = function(details, callback) {
 		try {
 			json = JSON.parse(body);
 		} catch(e) {
+			deleteMobileCookies();
 			callback(e);
 			return;
 		}
+
+		if(!json.publickey_mod || !json.publickey_exp) {
+			deleteMobileCookies();
+			callback(new Error("Invalid RSA key received"));
+			return;
+		}
 		
 		var key = new RSA();
 		key.setPublic(json.publickey_mod, json.publickey_exp);
@@ -57,19 +103,24 @@ SteamCommunity.prototype.login = function(details, callback) {
 			"captchagid": self._captchaGid,
 			"emailauth": details.authCode || "",
 			"emailsteamid": "",
-			"loginfriendlyname": "",
 			"password": hex2b64(key.encrypt(details.password)),
 			"remember_login": "true",
 			"rsatimestamp": json.timestamp,
 			"twofactorcode": details.twoFactorCode || "",
-			"username": details.accountName
+			"username": details.accountName,
+			"oauth_client_id": "DE45CD61",
+			"oauth_scope": "read_profile write_profile read_client write_client",
+			"loginfriendlyname": "#login_emailauth_friendlyname_mobile"
 		};
 		
 		self.request.post({
 			"uri": "https://steamcommunity.com/login/dologin/",
 			"json": true,
-			"form": form
+			"form": form,
+			"headers": mobileHeaders
 		}, function(err, response, body) {
+			deleteMobileCookies();
+
 			if(self._checkHttpError(err, response, callback)) {
 				return;
 			}
@@ -94,9 +145,12 @@ SteamCommunity.prototype.login = function(details, callback) {
 				callback(new Error(body.message || "Unknown error"));
 			} else {
 				var sessionID = generateSessionID();
+				var oAuth = JSON.parse( body.oauth );
 				self._jar.setCookie(Request.cookie('sessionid=' + sessionID), 'http://steamcommunity.com');
 				
-				self.steamID = new SteamID(body.transfer_parameters.steamid);
+				self.steamID = new SteamID(oAuth.steamid);
+				self.oAuthToken = oAuth.oauth_token;
+
 				var cookies = self._jar.getCookieString("https://steamcommunity.com").split(';').map(function(cookie) {
 					return cookie.trim();
 				});
@@ -111,10 +165,53 @@ SteamCommunity.prototype.login = function(details, callback) {
 					}
 				}
 				
-				callback(null, sessionID, cookies, steamguard);
+				callback(null, sessionID, cookies, steamguard, oAuth.oauth_token);
 			}
 		});
 	});
+
+	function deleteMobileCookies() {
+		var cookie = Request.cookie('mobileClientVersion=');
+		cookie.expires = new Date(0);
+		self._jar.setCookie(cookie, "https://steamcommunity.com");
+
+		cookie = Request.cookie('mobileClient=');
+		cookie.expires = new Date(0);
+		self._jar.setCookie(cookie, "https://steamcommunity.com");
+	}
+};
+
+SteamCommunity.prototype.oAuthLogin = function(steamguard, token, callback) {
+	steamguard = steamguard.split('||');
+	var steamID = new SteamID(steamguard[0]);
+
+	var self = this;
+	this.request.post({
+		"uri": "https://api.steampowered.com/IMobileAuthService/GetWGToken/v1/",
+		"form": {
+			"access_token": token
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(!body.response || !body.response.token || !body.response.token_secure) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		var cookies = [
+			'steamLogin=' + encodeURIComponent(steamID.getSteamID64() + '||' + body.response.token),
+			'steamLoginSecure=' + encodeURIComponent(steamID.getSteamID64() + '||' + body.response.token_secure),
+			'steamMachineAuth' + steamID.getSteamID64() + '=' + steamguard[1],
+			'sessionid=' + self.getSessionID()
+		];
+
+		self.setCookies(cookies);
+		callback(null, self.getSessionID(), cookies);
+	});
 };
 
 SteamCommunity.prototype.setCookies = function(cookies) {
@@ -144,43 +241,8 @@ SteamCommunity.prototype.getSessionID = function() {
 };
 
 function generateSessionID() {
-	return Math.floor(Math.random() * 1000000000);
-};
-
-SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
-	var self = this;
-	this.request("https://steamcommunity.com/dev/apikey", function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		if(body.match(/<h2>Access Denied<\/h2>/)) {
-			return callback("Access Denied");
-		}
-		
-		var match = body.match(/<p>Key: ([0-9A-F]+)<\/p>/);
-		if(match) {
-			// We already have an API key registered
-			callback(null, match[1]);
-		} else {
-			// We need to register a new API key
-			self.request.post('https://steamcommunity.com/dev/registerkey', {
-				"form": {
-					"domain": domain,
-					"agreeToTerms": "agreed",
-					"sessionid": self.getSessionID(),
-					"Submit": "Register"
-				}
-			}, function(err, response, body) {
-				if(err || response.statusCode >= 400) {
-					return callback(err.message || "HTTP error " + response.statusCode);
-				}
-				
-				self.getWebApiKey(domain, callback);
-			});
-		}
-	});
-};
+	return require('crypto').randomBytes(12).toString('hex');
+}
 
 SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 	this.request.post("https://steamcommunity.com/parental/ajaxunlock", {
@@ -210,6 +272,7 @@ SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 };
 
 SteamCommunity.prototype.getNotifications = function(callback) {
+	var self = this;
 	this.request.get("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
 		if(self._checkHttpError(err, response, callback)) {
 			return;
@@ -245,6 +308,7 @@ SteamCommunity.prototype.getNotifications = function(callback) {
 };
 
 SteamCommunity.prototype.resetItemNotifications = function(callback) {
+	var self = this;
 	this.request.get("https://steamcommunity.com/my/inventory", function(err, response, body) {
 		if(!callback) {
 			return;
@@ -294,7 +358,7 @@ SteamCommunity.prototype._myProfile = function(endpoint, form, callback) {
 		
 		var match = response.headers.location.match(/steamcommunity\.com(\/(id|profiles)\/[^\/]+)\/?/);
 		if(!match) {
-			callback("Can't get profile URL");
+			callback(new Error("Can't get profile URL"));
 			return;
 		}
 		
@@ -308,7 +372,12 @@ SteamCommunity.prototype._checkHttpError = function(err, response, callback) {
 		return true;
 	}
 	
-	if(response.statusCode != 200) {
+	if(response.statusCode >= 300 && response.statusCode <= 399 && response.headers.location.indexOf('/login') != -1) {
+		callback(new Error("Not Logged In"));
+		return true;
+	}
+	
+	if(response.statusCode >= 400) {
 		var error = new Error("HTTP error " + response.statusCode);
 		error.code = response.statusCode;
 		callback(error);
@@ -323,7 +392,16 @@ require('./components/profile.js');
 require('./components/market.js');
 require('./components/groups.js');
 require('./components/users.js');
+require('./components/inventoryhistory.js');
+require('./components/webapi.js');
+require('./components/twofactor.js');
+require('./components/confirmations.js');
 require('./classes/CMarketItem.js');
 require('./classes/CMarketSearchResult.js');
 require('./classes/CSteamGroup.js');
 require('./classes/CSteamUser.js');
+
+/**
+ @callback SteamCommunity~genericErrorCallback
+ @param {Error|null} err - An Error object on failure, or null on success
+ */

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "steamcommunity",
-	"version": "3.7.0",
+	"version": "3.18.0",
 	"description": "Provides an interface for logging into and interacting with the Steam Community website",
 	"keywords": ["steam", "steam community"],
 	"homepage": "https://github.com/DoctorMcKay/node-steamcommunity",
@@ -13,10 +13,12 @@
 		"url": "https://github.com/DoctorMcKay/node-steamcommunity.git"
 	},
 	"dependencies": {
-		"request":			"^2.58.0",
+		"request":			"^2.61.0",
 		"node-bignumber":	"^1.2.1",
-		"steamid":			"^0.3.0",
-		"xml2js":			"^0.4.9",
-		"cheerio":			"^0.19.0"
+		"steamid":			"^0.3.1",
+		"xml2js":			"^0.4.11",
+		"cheerio":			"^0.19.0",
+		"async":			"^1.4.2",
+		"steam-totp":		"^1.0.0"
 	}
 }