3.19.4

https://github.com/DoctorMcKay/node-steam-tradeoffer-manager/issues/120#issuecomment-200179648

.gitignore

@@ -1,2 +1,3 @@
 node_modules/*
 test.js
+.idea/

CONTRIBUTING.md

@@ -0,0 +1,35 @@
+# Contributing to SteamCommunity
+
+Thanks for your interest in making `SteamCommunity` better! I'd appreciate it if you read over this document quickly
+before you submit your issue or pull request. It'll make things go much smoother.
+
+# Issues
+
+Submitting an issue?
+
+- If you're **reporting a bug**, please include all relevant details.
+	- A descriptive title helps for one. Titles of just "Error" or "It doesn't work" really don't help.
+	- Please describe what you're trying to do, what actually happens, and what you can do to reproduce the problem.
+	- If you have an error message or a crash, please include the full text of the error message and the stack trace.
+	- Include the relevant snippet of your code. Wrap it in \`\`\`js /* code */ \`\`\` and GitHub [will format it nicely for you](https://help.github.com/articles/github-flavored-markdown/#syntax-highlighting).
+- If you're **requesting a feature**, please be descriptive and understanding.
+	- A good title makes a difference. Please briefly describe what you're requesting in the title.
+	- Be descriptive in the issue body, too. Say what you want to do, and ideally what the method should be named.
+	- Be understanding if I don't think that your feature request falls within the scope of this module.
+- If you're **asking a question** or **requesting support**, please don't submit a GitHub issue.
+	- Issues are only for problems directly relating to the module's code.
+	- Please [post a thread in the dedicated forum](https://dev.doctormckay.com/forum/8-node-steamcommunity/) instead.
+
+# Pull Requests
+
+Submitting a pull request? Great! Thanks for contributing your time and code! Please keep the following in mind.
+
+- Please follow the existing code style.
+	- Tabs for indentation
+	- camelCase for variables and functions
+	- Opening braces on the same line as the if/for/while statement
+	- etc.
+- Please avoid breaking changes. If you make a breaking change that can be done in a backwards-compatible manner, I won't accept it.
+- Please don't increment the version number in `package.json`. I'll do that myself when I publish it to npm.
+- Please include a brief description of your change in the pull request if it's not immediately apparent from the code.
+- Be understanding if I don't think that your change falls within the scope of this module.

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Alexander Corn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -1,15 +1,23 @@
 # Steam Community for Node.js
+[![npm version](https://img.shields.io/npm/v/steamcommunity.svg)](https://npmjs.com/package/steamcommunity)
+[![npm downloads](https://img.shields.io/npm/dm/steamcommunity.svg)](https://npmjs.com/package/steamcommunity)
+[![dependencies](https://img.shields.io/david/DoctorMcKay/node-steamcommunity.svg)](https://david-dm.org/DoctorMcKay/node-steamcommunity)
+[![license](https://img.shields.io/npm/l/steamcommunity.svg)](https://github.com/DoctorMcKay/node-steamcommunity/blob/master/LICENSE)
+[![paypal](https://img.shields.io/badge/paypal-donate-yellow.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=N36YVAT42CZ4G&item_name=node%2dsteamcommunity&currency_code=USD)
 
-This lightweight module provides an easy interface for the Steam Community website. This module can be used to simply login to steamcommunity.com for use with other libraries, or to interact with steamcommunity.com.
+This module provides an easy interface for the Steam Community website. This module can be used to simply login to steamcommunity.com for use with other libraries, or to interact with steamcommunity.com.
 
-It supports Steam Guard but doesn't support CAPTCHAs, so make sure you don't provide Steam with an incorrect password.
+It supports Steam Guard and CAPTCHAs.
 
-# Installation
-
-Install it from npm:
-
-    $ npm install steamcommunity
+**Have a question about the module or coding in general? *Do not create a GitHub issue.* GitHub issues are for feature
+requests and bug reports. Instead, post in the [dedicated forum](https://dev.doctormckay.com/forum/8-node-steamcommunity/).
+Such issues may be ignored!**
 
 # Documentation
 
-As of version 1.0.0, documentation is on the [GitHub wiki](https://github.com/DoctorMcKay/node-steamcommunity/wiki).
+Documentation is available on the [GitHub wiki](https://github.com/DoctorMcKay/node-steamcommunity/wiki).
+
+# Support
+
+Report bugs on the [issue tracker](https://github.com/DoctorMcKay/node-steamcommunity/issues) or ask questions
+on the [dedicated forum](https://dev.doctormckay.com/forum/8-node-steamcommunity/).

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/CMarketItem.js

@@ -1,10 +1,15 @@
 var SteamCommunity = require('../index.js');
 var Cheerio = require('cheerio');
 
-SteamCommunity.prototype.getMarketItem = function(appid, hashName, callback) {
+SteamCommunity.prototype.getMarketItem = function(appid, hashName, currency, callback) {
+	if (typeof currency == "function") {
+		callback = currency;
+		currency = 1;
+	}
 	var self = this;
-	this.request("https://steamcommunity.com/market/listings/" + appid + "/" + encodeURIComponent(hashName), function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
+	this.httpRequest("https://steamcommunity.com/market/listings/" + appid + "/" + encodeURIComponent(hashName), function(err, response, body) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -13,23 +18,21 @@ SteamCommunity.prototype.getMarketItem = function(appid, hashName, callback) {
 			callback(new Error("There are no listings for this item."));
 			return;
 		}
-		
-		var item = new CMarketItem(self, body, $);
-		if(item.commodity) {
-			item.updatePrice(function(err) {
-				if(err) {
-					callback(err);
-				} else {
-					callback(null, item);
-				}
-			});
-		} else {
-			callback(null, item);
-		}
-	});
+
+		var item = new CMarketItem(appid, hashName, self, body, $);
+		item.updatePrice(currency, function(err) {
+			if(err) {
+				callback(err);
+			} else {
+				callback(null, item);
+			}
+		});
+	}, "steamcommunity");
 };
 
-function CMarketItem(community, body, $) {
+function CMarketItem(appid, hashName, community, body, $) {
+	this._appid = appid;
+	this._hashName = hashName;
 	this._community = community;
 	this._$ = $;
 	
@@ -38,6 +41,12 @@ function CMarketItem(community, body, $) {
 	if(match) {
 		this._country = match[1];
 	}
+
+	this._language = "english";
+	match = body.match(/var g_strLanguage = "([^"]+)";/);
+	if(match) {
+		this._language = match[1];
+	}
 	
 	this.commodity = false;
 	var match = body.match(/Market_LoadOrderSpread\(\s*(\d+)\s*\);/);
@@ -62,37 +71,45 @@ function CMarketItem(community, body, $) {
 			// ignore
 		}
 	}
-	
-	this.quantity = 0;
-	this.lowestPrice = 0;
-	
-	if(!this.commodity) {
-		var total = $('#searchResults_total');
-		if(total) {
-			this.quantity = parseInt(total.text().replace(/[^\d]/g, '').trim(), 10);
-		}
-		
-		var lowest = $('.market_listing_price.market_listing_price_with_fee');
-		if(lowest[0]) {
-			this.lowestPrice = parseInt($(lowest[0]).text().replace(/[^\d]/g, '').trim(), 10);
+
+	this.firstAsset = null;
+	this.assets = null;
+	match = body.match(/var g_rgAssets = (.*);/);
+	if (match) {
+		try {
+			this.assets = JSON.parse(match[1]);
+			this.assets = this.assets['730']['2'];
+			this.firstAsset = this.assets[Object.keys(this.assets)[0]];
+		} catch (e) {
+			// ignore
 		}
 	}
-	
+
+	this.quantity = 0;
+	this.lowestPrice = 0;
 	// TODO: Buying listings and placing buy orders
 }
 
-CMarketItem.prototype.updatePrice = function(callback) {
+CMarketItem.prototype.updatePrice = function (currency, callback) {
+	if (this.commodity) {
+		this.updatePriceForCommodity(currency, callback);
+	} else {
+		this.updatePriceForNonCommodity(currency, callback);
+	}
+};
+
+CMarketItem.prototype.updatePriceForCommodity = function(currency, callback) {
 	if(!this.commodity) {
 		throw new Error("Cannot update price for non-commodity item");
 	}
-	
-	// TODO: Currency option maybe?
+
 	var self = this;
-	this._community.request({
-		"uri": "https://steamcommunity.com/market/itemordershistogram?country=US&language=english&currency=1&item_nameid=" + this.commodityID,
-		"json": true,
+	this._community.httpRequest({
+		"uri": "https://steamcommunity.com/market/itemordershistogram?country=US&language=english&currency=" + currency + "&item_nameid=" + this.commodityID,
+		"json": true
 	}, function(err, response, body) {
-		if(self._community._checkHttpError(err, response, callback)) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -122,5 +139,50 @@ CMarketItem.prototype.updatePrice = function(callback) {
 		if(callback) {
 			callback(null);
 		}
-	});
+	}, "steamcommunity");
+};
+
+CMarketItem.prototype.updatePriceForNonCommodity = function (currency, callback) {
+	if(this.commodity) {
+		throw new Error("Cannot update price for commodity item");
+	}
+
+	var self = this;
+	this._community.httpRequest({
+		"uri": "https://steamcommunity.com/market/listings/" +
+			this._appid + "/" +
+			encodeURIComponent(this._hashName) +
+			"/render/?query=&start=0&count=10&country=US&language=english&currency=" + currency,
+		"json": true
+	}, function(err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		if (body.success != 1) {
+			callback && callback(new Error("Error " + body.success));
+			return;
+		}
+
+		var match = body.total_count;
+		if (match) {
+			self.quantity = parseInt(match, 10);
+		}
+
+		var lowestPrice;
+		var $ = Cheerio.load(body.results_html);
+		match = $(".market_listing_price.market_listing_price_with_fee");
+		if (match) {
+			for (var i = 0; i < match.length; i++) {
+				lowestPrice = parseFloat($(match[i]).text().replace(",", ".").replace(/[^\d.]/g, ''));
+				if (!isNaN(lowestPrice)) {
+					self.lowestPrice = lowestPrice;
+					break;
+				}
+			}
+		}
+
+		callback && callback(null);
+	}, "steamcommunity");
 };

classes/CMarketSearchResult.js

@@ -27,7 +27,7 @@ SteamCommunity.prototype.marketSearch = function(options, callback) {
 	qs.count = 100;
 	qs.sort_column = 'price';
 	qs.sort_dir = 'asc';
-	performSearch.call(this, this.request, qs, [], callback);
+	performSearch.call(this, this.httpRequest, qs, [], callback);
 };
 
 function performSearch(request, qs, results, callback) {
@@ -40,7 +40,8 @@ function performSearch(request, qs, results, callback) {
 		},
 		"json": true
 	}, function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -69,9 +70,9 @@ 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);
 		}
-	});
+	}, "steamcommunity");
 }
 
 function CMarketSearchResult(row) {

classes/CSteamGroup.js

@@ -1,9 +1,10 @@
 var SteamCommunity = require('../index.js');
+var Helpers = require('../components/helpers.js');
 var SteamID = require('steamid');
 var xml2js = require('xml2js');
 
 SteamCommunity.prototype.getSteamGroup = function(id, callback) {
-	if(typeof id !== 'string' && !(typeof id === 'object' && id.__proto__ === SteamID.prototype)) {
+	if(typeof id !== 'string' && !Helpers.isSteamID(id)) {
 		throw new Error("id parameter should be a group URL string or a SteamID object");
 	}
 	
@@ -12,12 +13,9 @@ SteamCommunity.prototype.getSteamGroup = function(id, callback) {
 	}
 	
 	var self = this;
-	this.request("https://steamcommunity.com/" + (typeof id === 'string' ? "groups/" + id : "gid/" + id.toString()) + "/memberslistxml/?xml=1", function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		if(self._checkCommunityError(body, callback)) {
+	this.httpRequest("https://steamcommunity.com/" + (typeof id === 'string' ? "groups/" + id : "gid/" + id.toString()) + "/memberslistxml/?xml=1", function(err, response, body) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -29,7 +27,7 @@ SteamCommunity.prototype.getSteamGroup = function(id, callback) {
 			
 			callback(null, new CSteamGroup(self, result.memberList));
 		});
-	});
+	}, "steamcommunity");
 };
 
 function CSteamGroup(community, groupData) {
@@ -59,228 +57,51 @@ CSteamGroup.prototype.getAvatarURL = function(size, protocol) {
 	}
 };
 
-CSteamGroup.prototype.getMembers = function(callback, members, link) {
-	members = members || [];
-	link = link || "http://steamcommunity.com/gid/" + this.steamID.toString() + "/memberslistxml/?xml=1";
+CSteamGroup.prototype.getMembers = function(addresses, callback) {
+	if(typeof addresses === 'function') {
+		callback = addresses;
+		addresses = null;
+	}
 	
-	var self = this;
-	this._community.request(link, function(err, response, body) {
-		if(self._community._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		xml2js.parseString(body, function(err, result) {
-			if(err) {
-				callback(err);
-				return;
-			}
-			
-			members = members.concat(result.memberList.members[0].steamID64.map(function(steamID) {
-				return new SteamID(steamID);
-			}));
-			
-			if(result.memberList.nextPageLink) {
-				self.getMembers(callback, members, result.memberList.nextPageLink[0]);
-			} else {
-				callback(null, members);
-			}
-		});
-	});
+	this._community.getGroupMembers(this.steamID, callback, null, null, addresses, 0);
 };
 
 CSteamGroup.prototype.join = function(callback) {
-	var form = {
-		"action": "join",
-		"sessionID": this._community.getSessionID()
-	};
-	
-	var self = this;
-	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString(), {"form": form}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.joinGroup(this.steamID, callback);
 };
 
 CSteamGroup.prototype.leave = function(callback) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "leaveGroup",
-		"groupId": this.steamID.toString()
-	};
-	
-	var self = this;
-	this._community._myProfile("home_process", form, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	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) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "post",
-		"headline": headline,
-		"body": content
-	};
-	
-	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/announcements", {"form": form}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	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, callback) {
+	this._community.deleteGroupAnnouncement(this.steamID, annoucementID, callback)
 };
 
 CSteamGroup.prototype.scheduleEvent = function(name, type, description, time, server, callback) {
-	// Event types: ChatEvent - Chat, OtherEvent - A lil somethin somethin, PartyEvent - Party!, MeetingEvent - Important meeting, SpecialCauseEvent - Special cause (charity ball?), MusicAndArtsEvent - Music or Art type thing, SportsEvent - Sporting endeavor, TripEvent - Out of town excursion
-	// Passing a number for type will make it a game event for that appid
-	
-	if(typeof server === 'function') {
-		callback = server;
-		server = {"ip": "", "password": ""};
-	} else if(typeof server === 'string') {
-		server = {"ip": server, "password": ""};
-	} else {
-		server = {"ip": "", "password": ""};
-	}
-	
-	var form = {
-		"sessionid": this._community.getSessionID(),
-		"action": "newEvent",
-		"tzOffset": new Date().getTimezoneOffset() * -60,
-		"name": name,
-		"type": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? "GameEvent" : type),
-		"appID": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? type : ''),
-		"serverIP": server.ip,
-		"serverPassword": server.password,
-		"notes": description,
-		"eventQuickTime": "now"
-	};
-	
-	if(time === null) {
-		form.startDate = 'MM/DD/YY';
-		form.startHour = '12';
-		form.startMinute = '00';
-		form.startAMPM = 'PM';
-		form.timeChoice = 'quick';
-	} else {
-		form.startDate = (time.getMonth() + 1 < 10 ? '0' : '') + (time.getMonth() + 1) + '/' + (time.getDate() < 10 ? '0' : '') + time.getDate() + '/' + time.getFullYear().toString().substring(2);
-		form.startHour = (time.getHours() === 0 ? '12' : (time.getHours() > 12 ? time.getHours() - 12 : time.getHours()));
-		form.startMinute = (time.getMinutes() < 10 ? '0' : '') + time.getMinutes();
-		form.startAMPM = (time.getHours() <= 12 ? 'AM' : 'PM');
-		form.timeChoice = 'specific';
-	}
-	
-	var self = this;
-	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit", {"form": form}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.scheduleGroupEvent(this.steamID, name, type, description, time, server, callback);
 };
 
 CSteamGroup.prototype.setPlayerOfTheWeek = function(steamID, callback) {
-	var form = {
-		"xml": 1,
-		"action": "potw",
-		"memberId": steamID.getSteam3RenderedID(),
-		"sessionid": this._community.getSessionID()
-	};
-	
-	var self = this;
-	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/potwEdit", {"form": form}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode != 200) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		xml2js.parseString(body, function(err, results) {
-			if(err) {
-				callback(err);
-				return;
-			}
-			
-			if(results.response.results[0] == 'OK') {
-				callback(null, new SteamID(results.response.oldPOTW[0]), new SteamID(results.response.newPOTW[0]));
-			} else {
-				callback(new Error(results.response.results[0]));
-			}
-		});
-	});
+	this._community.setGroupPlayerOfTheWeek(this.steamID, steamID, callback);
 };
 
 CSteamGroup.prototype.kick = function(steamID, callback) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "kick",
-		"memberId": steamID.toString(),
-		"queryString": ""
-	};
-	
-	var self = this;
-	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/membersManage", {"form": form}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.kickGroupMember(this.steamID, steamID, callback);
+};
+
+CSteamGroup.prototype.getHistory = function(page, callback) {
+	this._community.getGroupHistory(this.steamID, page, callback);
 };

classes/CSteamUser.js

@@ -1,9 +1,10 @@
 var SteamCommunity = require('../index.js');
+var Helpers = require('../components/helpers.js');
 var SteamID = require('steamid');
 var xml2js = require('xml2js');
 
 SteamCommunity.prototype.getSteamUser = function(id, callback) {
-	if(typeof id !== 'string' && !(typeof id === 'object' && id.__proto__ === SteamID.prototype)) {
+	if(typeof id !== 'string' && !Helpers.isSteamID(id)) {
 		throw new Error("id parameter should be a user URL string or a SteamID object");
 	}
 	
@@ -12,12 +13,9 @@ SteamCommunity.prototype.getSteamUser = function(id, callback) {
 	}
 	
 	var self = this;
-	this.request("http://steamcommunity.com/" + (typeof id === 'string' ? "id/" + id : "profiles/" + id.toString()) + "/?xml=1", function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		if(self._checkCommunityError(body, callback)) {
+	this.httpRequest("http://steamcommunity.com/" + (typeof id === 'string' ? "id/" + id : "profiles/" + id.toString()) + "/?xml=1", function(err, response, body) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -40,32 +38,41 @@ 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));
 		});
-	});
+	}, "steamcommunity");
 };
 
 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;
@@ -81,13 +88,21 @@ function CSteamUser(community, userData, customurl) {
 	var self = this;
 	if(userData.groups && userData.groups[0] && userData.groups[0].group) {
 		this.groups = userData.groups[0].group.map(function(group) {
-			if(group['$'] && group['$'].isPrimary) {
+			if(group['$'] && group['$'].isPrimary === "1") {
 				self.primaryGroup = new SteamID(group.groupID64[0]);
 			}
 			
 			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) {
@@ -107,124 +122,38 @@ CSteamUser.prototype.getAvatarURL = function(size, protocol) {
 };
 
 CSteamUser.prototype.addFriend = function(callback) {
-	var self = this;
-	this._community.request.post('https://steamcommunity.com/actions/AddFriendAjax', {"form": {"accept_invite": 0, "sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(self._community._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		var json;
-		try {
-			json = JSON.parse(body);
-		} catch(e) {
-			callback(e);
-			return;
-		}
-		
-		if(json.success) {
-			callback(null);
-		} else {
-			callback(new Error("Unknown error"));
-		}
-	});
+	this._community.addFriend(this.steamID, callback);
 };
 
 CSteamUser.prototype.acceptFriendRequest = function(callback) {
-	var self = this;
-	this._community.request.post('https://steamcommunity.com/actions/AddFriendAjax', {"form": {"accept_invite": 1, "sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(self._community._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.acceptFriendRequest(this.steamID, callback);
 };
 
 CSteamUser.prototype.removeFriend = function(callback) {
-	var self = this;
-	this._community.request.post('https://steamcommunity.com/actions/RemoveFriendAjax', {"form": {"sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(self._community._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.removeFriend(this.steamID, callback);
+
 };
 
 CSteamUser.prototype.blockCommunication = function(callback) {
-	var self = this;
-	this._community.request.post('https://steamcommunity.com/actions/BlockUserAjax', {"form": {"sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(self._community._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.blockCommunication(this.steamID, callback);
 };
 
 CSteamUser.prototype.unblockCommunication = function(callback) {
-	var form = {"action": "unignore"};
-	form['friends[' + this.steamID.toString() + ']'] = 1;
-	
-	this._community._myProfile('friends/blocked/', form, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.unblockCommunication(this.steamID, callback);
 };
 
 CSteamUser.prototype.comment = function(message, callback) {
-	this._community.request.post('https://steamcommunity.com/comment/Profile/post/' + this.steamID.toString() + '/-1/', {"form": {
-		"comment": message,
-		"count": 6,
-		"sessionid": this._community.getSessionID()
-	}}, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode != 200) {
-			callback(err || new Error("HTTP error " + response.statusCode));
-			return;
-		}
-		
-		var json;
-		try {
-			json = JSON.parse(body);
-		} catch(e) {
-			callback(e);
-			return;
-		}
-		
-		if(json.success) {
-			callback(null);
-		} else if(json.error) {
-			callback(new Error(json.error));
-		} else {
-			callback(new Error("Unknown error"));
-		}
-	});
+	this._community.postUserComment(this.steamID, 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,27 +40,19 @@ 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));
+	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;
 		}
 		
-		var match = body.match(/[0-9a-f]{32}/);
-		if(!match) {
-			self.emit('debug', 'Couldn\'t find a WebAPI chat token in the response.');
-			self.chatState = SteamCommunity.ChatState.LogOnFailed;
-			setTimeout(self.chatLogon.bind(self), 5000);
-			return;
-		}
-		
-		self.request.post({
+		self.httpRequestPost({
 			"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
 			};
 			
@@ -90,7 +82,7 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 			self.chatState = SteamCommunity.ChatState.LoggedOn;
 			self.emit('chatLoggedOn');
 			self._chatPoll();
-		});
+		}, "steamcommunity");
 	});
 };
 
@@ -109,8 +101,9 @@ SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback)
 	}
 	
 	type = type || 'saytext';
-	
-	this.request.post({
+
+	var self = this;
+	this.httpRequestPost({
 		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Message/v1",
 		"form": {
 			"access_token": this._chat.accessToken,
@@ -125,7 +118,8 @@ SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback)
 			return;
 		}
 		
-		if(self._checkHttpError(err, response, callback)) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -134,12 +128,12 @@ SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback)
 		} else {
 			callback(null);
 		}
-	});
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype.chatLogoff = function() {
 	var self = this;
-	this.request.post({
+	this.httpRequestPost({
 		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Logoff/v1",
 		"form": {
 			"access_token": this._chat.accessToken,
@@ -156,14 +150,14 @@ SteamCommunity.prototype.chatLogoff = function() {
 			delete self.chatFriends;
 			self.chatState = SteamCommunity.ChatState.Offline;
 		}
-	});
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype._chatPoll = function() {
 	this.emit('debug', 'Doing chat poll');
 	
 	var self = this;
-	this.request.post({
+	this.httpRequestPost({
 		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Poll/v1",
 		"form": {
 			"umqid": self._chat.umqid,
@@ -218,13 +212,13 @@ SteamCommunity.prototype._chatPoll = function() {
 					self.emit('debug', 'Unhandled chat message type: ' + message.type);
 			}
 		});
-	});
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype._chatUpdatePersona = function(steamID) {
 	this.emit('debug', 'Updating persona data for ' + steamID);
 	var self = this;
-	this.request({
+	this.httpRequest({
 		"uri": "https://steamcommunity.com/chat/friendstate/" + steamID.accountid,
 		"json": true
 	}, function(err, response, body) {
@@ -249,5 +243,5 @@ SteamCommunity.prototype._chatUpdatePersona = function(steamID) {
 
 		self.emit('chatPersonaState', steamID, persona);
 		self.chatFriends[steamID.getSteamID64()] = persona;
-	});
+	}, "steamcommunity");
 };

components/confirmations.js

@@ -0,0 +1,347 @@
+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) {
+			if (err.message == "Invalid protocol: steammobile:") {
+				err.message = "Not Logged In";
+			}
+
+			callback(err);
+			self._notifySessionExpired(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 = SteamTotp.getDeviceID(community.steamID);
+	params.a = community.steamID.getSteamID64();
+	params.k = key;
+	params.t = time;
+	params.m = "android";
+	params.tag = tag;
+
+	community.httpRequestGet({
+		"uri": "https://steamcommunity.com/mobileconf/" + url,
+		"qs": params,
+		"json": !!json
+	}, function(err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		callback(null, body);
+	}, "steamcommunity");
+}
+
+// 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 should probably be at least 10,000 to avoid rate-limits.
+ * @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) {
+				self.emit('debug', "Can't check confirmations: " + err.message);
+				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(err) {
+					if (err) {
+						self.emit('debug', "Can't accept confirmation #" + conf.id + ": " + err.message);
+					}
+
+					// We'll just retry next time we poll
+					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

@@ -0,0 +1,437 @@
+var SteamCommunity = require('../index.js');
+var SteamID = require('steamid');
+var xml2js = require('xml2js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.getGroupMembers = function(gid, callback, members, link, addresses, addressIdx) {
+	members = members || [];
+
+	if (!link) {
+		if (typeof gid !== 'string') {
+			// It's a SteamID object
+			link = "http://steamcommunity.com/gid/" + gid.toString() + "/memberslistxml/?xml=1";
+		} else {
+			try {
+				var sid = new SteamID(gid);
+				if (sid.type == SteamID.Type.CLAN && sid.isValid()) {
+					link = "http://steamcommunity.com/gid/" + sid.getSteamID64() + "/memberslistxml/?xml=1";
+				} else {
+					throw new Error("Doesn't particularly matter what this message is");
+				}
+			} catch (e) {
+				link = "http://steamcommunity.com/groups/" + gid + "/memberslistxml/?xml=1";
+			}
+		}
+	}
+
+	addressIdx = addressIdx || 0;
+
+	var options = {};
+	options.uri = link;
+
+	if(addresses) {
+		if(addressIdx >= addresses.length) {
+			addressIdx = 0;
+		}
+
+		options.localAddress = addresses[addressIdx];
+	}
+
+	var self = this;
+	this.httpRequest(options, function(err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		xml2js.parseString(body, function(err, result) {
+			if (err) {
+				callback(err);
+				return;
+			}
+
+			members = members.concat(result.memberList.members[0].steamID64.map(function(steamID) {
+				return new SteamID(steamID);
+			}));
+
+			if (result.memberList.nextPageLink) {
+				addressIdx++;
+				self.getGroupMembers(gid, callback, members, result.memberList.nextPageLink[0], addresses, addressIdx);
+			} else {
+				callback(null, members);
+			}
+		});
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.getGroupMembersEx = function(gid, addresses, callback) {
+	this.getGroupMembers(gid, callback, null, null, addresses, 0);
+};
+
+SteamCommunity.prototype.joinGroup = function(gid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64(),
+		"form": {
+			"action": "join",
+			"sessionID": this.getSessionID()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.leaveGroup = function(gid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this._myProfile("home_process", {
+		"sessionID": this.getSessionID(),
+		"action": "leaveGroup",
+		"groupId": gid.getSteamID64()
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	});
+};
+
+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.httpRequest({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/rss/" 
+	}, function(err, response, body) {
+		if (err) {
+			callback(err);
+			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");
+}
+
+SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"action": "post",
+			"headline": headline,
+			"body": content,
+			"languages[0][headline]": headline,
+			"languages[0][body]": content
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+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.httpRequestPost(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+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.httpRequestGet(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.scheduleGroupEvent = function(gid, name, type, description, time, server, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	// Event types: ChatEvent - Chat, OtherEvent - A lil somethin somethin, PartyEvent - Party!, MeetingEvent - Important meeting, SpecialCauseEvent - Special cause (charity ball?), MusicAndArtsEvent - Music or Art type thing, SportsEvent - Sporting endeavor, TripEvent - Out of town excursion
+	// Passing a number for type will make it a game event for that appid
+
+	if(typeof server === 'function') {
+		callback = server;
+		server = {"ip": "", "password": ""};
+	} else if(typeof server === 'string') {
+		server = {"ip": server, "password": ""};
+	} else {
+		server = {"ip": "", "password": ""};
+	}
+
+	var form = {
+		"sessionid": this.getSessionID(),
+		"action": "newEvent",
+		"tzOffset": new Date().getTimezoneOffset() * -60,
+		"name": name,
+		"type": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? "GameEvent" : type),
+		"appID": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? type : ''),
+		"serverIP": server.ip,
+		"serverPassword": server.password,
+		"notes": description,
+		"eventQuickTime": "now"
+	};
+
+	if(time === null) {
+		form.startDate = 'MM/DD/YY';
+		form.startHour = '12';
+		form.startMinute = '00';
+		form.startAMPM = 'PM';
+		form.timeChoice = 'quick';
+	} else {
+		form.startDate = (time.getMonth() + 1 < 10 ? '0' : '') + (time.getMonth() + 1) + '/' + (time.getDate() < 10 ? '0' : '') + time.getDate() + '/' + time.getFullYear().toString().substring(2);
+		form.startHour = (time.getHours() === 0 ? '12' : (time.getHours() > 12 ? time.getHours() - 12 : time.getHours()));
+		form.startMinute = (time.getMinutes() < 10 ? '0' : '') + time.getMinutes();
+		form.startAMPM = (time.getHours() <= 12 ? 'AM' : 'PM');
+		form.timeChoice = 'specific';
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/gid/" + gid.toString() + "/eventEdit",
+		"form": form
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.setGroupPlayerOfTheWeek = function(gid, steamID, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof steamID === 'string') {
+		steamID = new SteamID(steamID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/potwEdit",
+		"form": {
+			"xml": 1,
+			"action": "potw",
+			"memberId": steamID.getSteam3RenderedID(),
+			"sessionid": this.getSessionID()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode != 200) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		xml2js.parseString(body, function(err, results) {
+			if(err) {
+				callback(err);
+				return;
+			}
+
+			if(results.response.results[0] == 'OK') {
+				callback(null, new SteamID(results.response.oldPOTW[0]), new SteamID(results.response.newPOTW[0]));
+			} else {
+				callback(new Error(results.response.results[0]));
+			}
+		});
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.kickGroupMember = function(gid, steamID, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof steamID === 'string') {
+		steamID = new SteamID(steamID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/membersManage",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"action": "kick",
+			"memberId": steamID.getSteamID64(),
+			"queryString": ""
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.getGroupHistory = function(gid, page, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof page === 'function') {
+		callback = page;
+		page = 1;
+	}
+
+	var self = this;
+	this.httpRequest("https://steamcommunity.com/gid/" + gid.getSteamID64() + "/history?p=" + page, function(err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		var $ = Cheerio.load(body);
+		var output = {};
+
+		var paging = $('.group_paging p').text();
+		var match = paging.match(/(\d+) - (\d+) of (\d+)/);
+
+		if(match) {
+			output.first = parseInt(match[1], 10);
+			output.last = parseInt(match[2], 10);
+			output.total = parseInt(match[3], 10);
+		}
+
+		output.items = [];
+		var currentYear = (new Date()).getFullYear();
+		var lastDate = Date.now();
+
+		Array.prototype.forEach.call($('.historyItem, .historyItemb'), function(item) {
+			var data = {};
+
+			var $item = $(item);
+			data.type = $item.find('.historyShort').text().replace(/ /g, '');
+
+			var users = $item.find('.whiteLink[data-miniprofile]');
+			var sid;
+			if(users[0]) {
+				sid = new SteamID();
+				sid.universe = SteamID.Universe.PUBLIC;
+				sid.type = SteamID.Type.INDIVIDUAL;
+				sid.instance = SteamID.Instance.DESKTOP;
+				sid.accountid = $(users[0]).data('miniprofile');
+				data.user = sid;
+			}
+
+			if(users[1]) {
+				sid = new SteamID();
+				sid.universe = SteamID.Universe.PUBLIC;
+				sid.type = SteamID.Type.INDIVIDUAL;
+				sid.instance = SteamID.Instance.DESKTOP;
+				sid.accountid = $(users[0]).data('miniprofile');
+				data.actor = sid;
+			}
+
+			// Figure out the date. Of course there's no year, because Valve
+			var dateParts = $item.find('.historyDate').text().split('@');
+			var date = dateParts[0].trim().replace(/(st|nd|th)$/, '').trim() + ', ' + currentYear;
+			var time = dateParts[1].trim().replace(/(am|pm)/, ' $1');
+
+			date = new Date(date + ' ' + time + ' UTC');
+
+			// If this date is in the future, or it's later than the previous one, decrement the year
+			if(date.getTime() > lastDate) {
+				date.setFullYear(date.getFullYear() - 1);
+			}
+
+			data.date = date;
+
+			output.items.push(data);
+		});
+
+		callback(null, output);
+	}, "steamcommunity");
+};

components/helpers.js

@@ -0,0 +1,13 @@
+exports.isSteamID = function(input) {
+	var keys = Object.keys(input);
+	if (keys.length != 4) {
+		return false;
+	}
+
+	// Make sure it has the keys we expect
+	keys = keys.filter(function(item) {
+		return ['universe', 'type', 'instance', 'accountid'].indexOf(item) != -1;
+	});
+
+	return keys.length == 4;
+};

components/http.js

@@ -0,0 +1,138 @@
+var SteamCommunity = require('../index.js');
+
+SteamCommunity.prototype.httpRequest = function(uri, options, callback, source) {
+	if (typeof uri === 'object') {
+		source = callback;
+		callback = options;
+		options = uri;
+		uri = options.url || options.uri;
+	} else if (typeof options === 'function') {
+		source = callback;
+		callback = options;
+		options = {};
+	}
+
+	options.url = options.uri = uri;
+
+	if (this._httpRequestConvenienceMethod) {
+		options.method = this._httpRequestConvenienceMethod;
+		delete this._httpRequestConvenienceMethod;
+	}
+
+	var requestID = ++this._httpRequestID;
+	source = source || "";
+
+	var self = this;
+	var continued = false;
+
+	if (!this.onPreHttpRequest || !this.onPreHttpRequest(requestID, source, options, continueRequest)) {
+		// No pre-hook, or the pre-hook doesn't want to delay the request.
+		continueRequest(null);
+	}
+
+	function continueRequest(err) {
+		if (continued) {
+			return;
+		}
+
+		continued = true;
+
+		if (err) {
+			if (callback) {
+				callback(err);
+			}
+
+			return;
+		}
+
+		self.request(options, function (err, response, body) {
+			var hasCallback = !!callback;
+			var httpError = options.checkHttpError !== false && self._checkHttpError(err, response, callback);
+			var communityError = !options.json && options.checkCommunityError !== false && self._checkCommunityError(body, httpError ? function () {} : callback); // don't fire the callback if hasHttpError did it already
+			var tradeError = !options.json && options.checkTradeError !== false && self._checkTradeError(body, httpError || communityError ? function () {} : callback); // don't fire the callback if either of the previous already did
+
+			self.emit('postHttpRequest', requestID, source, options, httpError || communityError || tradeError || null, response, body, {
+				"hasCallback": hasCallback,
+				"httpError": httpError,
+				"communityError": communityError,
+				"tradeError": tradeError
+			});
+
+			if(hasCallback && !(httpError || communityError || tradeError)) {
+				callback.apply(self, arguments);
+			}
+		});
+	}
+};
+
+SteamCommunity.prototype.httpRequestGet = function() {
+	this._httpRequestConvenienceMethod = "GET";
+	return this.httpRequest.apply(this, arguments);
+};
+
+SteamCommunity.prototype.httpRequestPost = function() {
+	this._httpRequestConvenienceMethod = "POST";
+	return this.httpRequest.apply(this, arguments);
+};
+
+SteamCommunity.prototype._notifySessionExpired = function(err) {
+	this.emit('sessionExpired', err);
+};
+
+SteamCommunity.prototype._checkHttpError = function(err, response, callback) {
+	if(err) {
+		callback(err);
+		return err;
+	}
+
+	if(response.statusCode >= 300 && response.statusCode <= 399 && response.headers.location.indexOf('/login') != -1) {
+		err = new Error("Not Logged In");
+		callback(err);
+		this._notifySessionExpired(err);
+		return err;
+	}
+
+	if(response.statusCode >= 400) {
+		err = new Error("HTTP error " + response.statusCode);
+		err.code = response.statusCode;
+		callback(err);
+		return err;
+	}
+
+	return false;
+};
+
+SteamCommunity.prototype._checkCommunityError = function(html, callback) {
+	var err;
+
+	if(typeof html === 'string' && html.match(/<h1>Sorry!<\/h1>/)) {
+		var match = html.match(/<h3>(.+)<\/h3>/);
+		err = new Error(match ? match[1] : "Unknown error occurred");
+		callback(err);
+		return err;
+	}
+
+	if (typeof html === 'string' && html.match(/g_steamID = false;/) && html.match(/<h1>Sign In<\/h1>/)) {
+		err = new Error("Not Logged In");
+		callback(err);
+		this._notifySessionExpired(err);
+		return err;
+	}
+
+	return false;
+};
+
+SteamCommunity.prototype._checkTradeError = function(html, callback) {
+	if (typeof html !== 'string') {
+		return false;
+	}
+
+	var match = html.match(/<div id="error_msg">\s*([^<]+)\s*<\/div>/);
+	if (match) {
+		var err = new Error(match[1].trim());
+		callback(new Error(err));
+		return err;
+	}
+
+	return false;
+};

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.httpRequest("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);
+		}
+	}, "steamcommunity");
+};
+
+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/market.js

@@ -0,0 +1,27 @@
+var SteamCommunity = require('../index.js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.getMarketApps = function(callback) {
+	var self = this;
+	this.httpRequest('https://steamcommunity.com/market/', function (err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		var $ = Cheerio.load(body);
+		if ($('.market_search_game_button_group')) {
+			apps = {};
+			$('.market_search_game_button_group > a').each(function (i, element) {
+				var e = Cheerio.load(element);
+				var name = e('.game_button_game_name').text().trim();
+				var url = element.attribs.href;
+				var appid = url.substr(url.indexOf('=') + 1);
+				apps[appid] = name;
+			});
+			callback(null, apps);
+		} else {
+			callback(new Error("Malformed response"));
+		}
+	}, "steamcommunity");
+};

components/profile.js

@@ -1,6 +1,7 @@
 var SteamCommunity = require('../index.js');
 var SteamID = require('steamid');
 var Cheerio = require('cheerio');
+var fs = require('fs');
 
 SteamCommunity.PrivacyState = {
 	"Private": 1,
@@ -100,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;
@@ -189,10 +190,6 @@ SteamCommunity.prototype.profileSettings = function(settings, callback) {
 				case 'inventoryGifts':
 					values.inventoryGiftPrivacy = settings[i] ? 1 : 0;
 					break;
-				
-				case 'emailConfirmation':
-					values.tradeConfirmationSetting = settings[i] ? 1 : 0;
-					break;
 			}
 		}
 		
@@ -211,3 +208,152 @@ SteamCommunity.prototype.profileSettings = function(settings, callback) {
 		});
 	});
 };
+
+SteamCommunity.prototype.uploadAvatar = function(image, format, callback) {
+	if(typeof format === 'function') {
+		callback = format;
+		format = null;
+	}
+
+	var self = this;
+
+	if(image instanceof Buffer) {
+		doUpload(image);
+	} else if(image.match(/^https?:\/\//)) {
+		this.httpRequestGet({
+			"uri": image,
+			"encoding": null
+		}, function(err, response, body) {
+			if(err || response.statusCode != 200) {
+				if(callback) {
+					callback(err ? new Error(err.message + " downloading image") : new Error("HTTP error " + response.statusCode + " downloading image"));
+				}
+
+				return;
+			}
+
+			if(!format) {
+				format = response.headers['content-type'];
+			}
+
+			doUpload(body);
+		}, "steamcommunity");
+	} else {
+		if(!format) {
+			format = image.match(/\.([^\.]+)$/);
+			if(format) {
+				format = format[1];
+			}
+		}
+
+		fs.readFile(image, function(err, file) {
+			if(err) {
+				if(callback) {
+					callback(err);
+				}
+
+				return;
+			}
+
+			doUpload(file);
+		})
+	}
+
+	function doUpload(buffer) {
+		if(!format) {
+			if(callback) {
+				callback(new Error("Unknown image format"));
+			}
+
+			return;
+		}
+
+		if(format.match(/^image\//)) {
+			format = format.substring(6);
+		}
+
+		var filename = '';
+		var contentType = '';
+
+		switch(format.toLowerCase()) {
+			case 'jpg':
+			case 'jpeg':
+				filename = 'avatar.jpg';
+				contentType = 'image/jpeg';
+				break;
+
+			case 'png':
+				filename = 'avatar.png';
+				contentType = 'image/png';
+				break;
+
+			case 'gif':
+				filename = 'avatar.gif';
+				contentType = 'image/gif';
+				break;
+
+			default:
+				if(callback) {
+					callback(new Error("Unknown or invalid image format"));
+				}
+
+				return;
+		}
+
+		self.httpRequestPost({
+			"uri": "https://steamcommunity.com/actions/FileUploader",
+			"formData": {
+				"MAX_FILE_SIZE": buffer.length,
+				"type": "player_avatar_image",
+				"sId": self.steamID.getSteamID64(),
+				"sessionid": self.getSessionID(),
+				"doSub": 1,
+				"json": 1,
+				"avatar": {
+					"value": buffer,
+					"options": {
+						"filename": filename,
+						"contentType": contentType
+					}
+				}
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(err) {
+				if(callback) {
+					callback(err);
+				}
+
+				return;
+			}
+
+			if(body && !body.success && body.message) {
+				if(callback) {
+					callback(new Error(body.message));
+				}
+
+				return;
+			}
+
+			if(response.statusCode != 200) {
+				if(callback) {
+					callback(new Error("HTTP error " + response.statusCode));
+				}
+
+				return;
+			}
+
+			if(!body || !body.success) {
+				if(callback) {
+					callback(new Error("Malformed response"));
+				}
+
+				return;
+			}
+
+			if(callback) {
+				callback(null, body.images.full);
+			}
+		}, "steamcommunity");
+	}
+};

components/twofactor.js

@@ -0,0 +1,151 @@
+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;
+		}
+
+		self.httpRequestPost({
+			"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": SteamTotp.getDeviceID(self.steamID),
+				"sms_phone_id": "1"
+			},
+			"json": true
+		}, function(err, response, body) {
+			if (err) {
+				callback(err);
+				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");
+	});
+};
+
+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.httpRequestPost({
+			"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 (err) {
+				callback(err);
+				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");
+	}
+};
+
+SteamCommunity.prototype.disableTwoFactor = function(revocationCode, callback) {
+	var self = this;
+
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		self.httpRequestPost({
+			"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 (err) {
+				callback(err);
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			if(!body.response.success) {
+				callback(new Error("Request failed"));
+				return;
+			}
+
+			// success = true means it worked
+			callback(null);
+		}, "steamcommunity");
+	});
+};

components/users.js

@@ -0,0 +1,296 @@
+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') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/actions/AddFriendAjax",
+		"form": {
+			"accept_invite": 0,
+			"sessionID": this.getSessionID(),
+			"steamid": userID.toString()
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		if(body.success) {
+			callback(null);
+		} else {
+			callback(new Error("Unknown error"));
+		}
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.acceptFriendRequest = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/actions/AddFriendAjax",
+		"form": {
+			"accept_invite": 1,
+			"sessionID": this.getSessionID(),
+			"steamid": userID.toString()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.removeFriend = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/actions/RemoveFriendAjax",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"steamid": userID.toString()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.blockCommunication = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/actions/BlockUserAjax",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"steamid": userID.toString()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		callback(err || null);
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.unblockCommunication = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var form = {"action": "unignore"};
+	form['friends[' + userID.toString() + ']'] = 1;
+
+	this._myProfile('friends/blocked/', form, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.postUserComment = function(userID, message, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/comment/Profile/post/" + userID.toString() + "/-1",
+		"form": {
+			"comment": message,
+			"count": 6,
+			"sessionid": this.getSessionID()
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		if(body.success) {
+			callback(null);
+		} else if(body.error) {
+			callback(new Error(body.error));
+		} else {
+			callback(new Error("Unknown error"));
+		}
+	}, "steamcommunity");
+};
+
+SteamCommunity.prototype.inviteUserToGroup = function(userID, groupID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var self = this;
+	this.httpRequestPost({
+		"uri": "https://steamcommunity.com/actions/GroupInvite",
+		"form": {
+			"group": groupID.toString(),
+			"invitee": userID.toString(),
+			"json": 1,
+			"sessionID": this.getSessionID(),
+			"type": "groupInvite"
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		if(body.results == 'OK') {
+			callback(null);
+		} else if(body.results) {
+			callback(new Error(body.results));
+		} else {
+			callback(new Error("Unknown error"));
+		}
+	}, "steamcommunity");
+};
+
+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.httpRequest("https://steamcommunity.com/profiles/" + userID.getSteamID64() + "/inventory/", function(err, response, body) {
+		if (err) {
+			callback(err);
+			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");
+};
+
+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.httpRequest({
+			"uri": "https://steamcommunity.com" + endpoint + "/inventory/json/" + appID + "/" + contextID,
+			"qs": {
+				"start": start,
+				"trading": tradableOnly ? 1 : undefined
+			},
+			"json": true
+		}, function(err, response, body) {
+			if (err) {
+				callback(err);
+				return;
+			}
+
+			if(!body || !body.success || !body.rgInventory || !body.rgDescriptions || !body.rgCurrency) {
+				if(body) {
+					callback(new Error(body.Error || "Malformed response"));
+				} else {
+					callback(new 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);
+			}
+		}, "steamcommunity");
+	}
+};

components/webapi.js

@@ -0,0 +1,65 @@
+var SteamCommunity = require('../index.js');
+
+SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
+	var self = this;
+	this.httpRequest({
+		"uri": "https://steamcommunity.com/dev/apikey",
+		"followRedirect": false
+	}, function(err, response, body) {
+		if (err) {
+			callback(err);
+			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.httpRequestPost('https://steamcommunity.com/dev/registerkey', {
+				"form": {
+					"domain": domain,
+					"agreeToTerms": "agreed",
+					"sessionid": self.getSessionID(),
+					"Submit": "Register"
+				}
+			}, function(err, response, body) {
+				if (err) {
+					callback(err);
+					return;
+				}
+
+				self.getWebApiKey(domain, callback);
+			}, "steamcommunity");
+		}
+	}, "steamcommunity");
+};
+
+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.httpRequest("https://steamcommunity.com/chat", function(err, response, body) {
+		if (err) {
+			callback(err);
+			return;
+		}
+
+		var match = body.match(/"([0-9a-f]{32})"/);
+		if (!match) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		callback(null, match[1]);
+	}, "steamcommunity");
+};

examples/edit-group-announcement.js

@@ -0,0 +1,119 @@
+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, captcha) {
+	community.login({
+		"accountName": accountName,
+		"password": password,
+		"authCode": authCode,
+		"twoFactorCode": twoFactorCode,
+		"captcha": captcha
+	}, 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;
+			}
+
+			if(err.message == 'CAPTCHA') {
+				console.log(err.captchaurl);
+				rl.question("CAPTCHA: ", function(captchaInput) {
+					doLogin(accountName, password, authCode, twoFactorCode, captchaInput);
+				});
+
+				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,107 @@
+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, captcha) {
+	community.login({
+		"accountName": accountName,
+		"password": password,
+		"authCode": authCode,
+		"captcha": captcha
+	}, 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;
+			}
+
+			if(err.message == 'CAPTCHA') {
+				console.log(err.captchaurl);
+				rl.question("CAPTCHA: ", function(captchaInput) {
+					doLogin(accountName, password, authCode, captchaInput);
+				});
+
+				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,20 +3,50 @@ 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() {
+function SteamCommunity(options) {
+	options = options || {};
+
 	this._jar = Request.jar();
 	this._captchaGid = -1;
-	this.request = Request.defaults({"jar": this._jar, "timeout": 50000});
+	this._httpRequestID = 0;
 	this.chatState = SteamCommunity.ChatState.Offline;
-	
+
+	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 = options.request || Request.defaults();
+	this.request = this.request.defaults(defaults);
+
 	// English
 	this._jar.setCookie(Request.cookie('Steam_Language=english'), 'https://steamcommunity.com');
+
+	// UTC
+	this._jar.setCookie(Request.cookie('timezoneOffset=0,0'), 'https://steamcommunity.com');
 }
 
 SteamCommunity.prototype.login = function(details, callback) {
@@ -26,57 +56,79 @@ 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) {
-		if(err) {
+
+	// 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.httpRequestPost("https://steamcommunity.com/login/getrsakey/", {
+		"form": {"username": details.accountName},
+		"headers": mobileHeaders,
+		"json": true
+	}, function(err, response, body) {
+		// Remove the mobile cookies
+		if (err) {
+			deleteMobileCookies();
 			callback(err);
 			return;
 		}
-		
-		var json;
-		try {
-			json = JSON.parse(body);
-		} catch(e) {
-			callback(e);
+
+		if(!body.publickey_mod || !body.publickey_exp) {
+			deleteMobileCookies();
+			callback(new Error("Invalid RSA key received"));
 			return;
 		}
 		
 		var key = new RSA();
-		key.setPublic(json.publickey_mod, json.publickey_exp);
+		key.setPublic(body.publickey_mod, body.publickey_exp);
 		
-		var form = {
-			"captcha_text": details.captcha || "",
-			"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
-		};
-		
-		self.request.post({
+		self.httpRequestPost({
 			"uri": "https://steamcommunity.com/login/dologin/",
 			"json": true,
-			"form": form
+			"form": {
+				"captcha_text": details.captcha || "",
+				"captchagid": self._captchaGid,
+				"emailauth": details.authCode || "",
+				"emailsteamid": "",
+				"password": hex2b64(key.encrypt(details.password)),
+				"remember_login": "true",
+				"rsatimestamp": body.timestamp,
+				"twofactorcode": details.twoFactorCode || "",
+				"username": details.accountName,
+				"oauth_client_id": "DE45CD61",
+				"oauth_scope": "read_profile write_profile read_client write_client",
+				"loginfriendlyname": "#login_emailauth_friendlyname_mobile",
+				"donotcache": Date.now()
+			},
+			"headers": mobileHeaders
 		}, function(err, response, body) {
-			if(self._checkHttpError(err, response, callback)) {
+			deleteMobileCookies();
+
+			if (err) {
+				callback(err);
 				return;
 			}
-			
+
+			var error;
 			if(!body.success && body.emailauth_needed) {
 				// Steam Guard (email)
-				var error = new Error("SteamGuard");
+				error = new Error("SteamGuard");
 				error.emaildomain = body.emaildomain;
 				
 				callback(error);
 			} else if(!body.success && body.requires_twofactor) {
 				// Steam Guard (app)
 				callback(new Error("SteamGuardMobile"));
-			} else if(!body.success && body.captcha_needed) {
-				var error = new Error("CAPTCHA");
-				error.captchaurl = "https://steamcommunity.com/public/captcha.php?gid=" + body.captcha_gid;
+			} else if(!body.success && body.captcha_needed && body.message.match(/Please verify your humanity/)) {
+				error = new Error("CAPTCHA");
+				error.captchaurl = "https://steamcommunity.com/login/rendercaptcha/?gid=" + body.captcha_gid;
 				
 				self._captchaGid = body.captcha_gid;
 				
@@ -85,9 +137,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();
 				});
@@ -102,10 +157,54 @@ SteamCommunity.prototype.login = function(details, callback) {
 					}
 				}
 				
-				callback(null, sessionID, cookies, steamguard);
+				callback(null, sessionID, cookies, steamguard, oAuth.oauth_token);
 			}
-		});
-	});
+		}, "steamcommunity");
+	}, "steamcommunity");
+
+	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.httpRequestPost({
+		"uri": "https://api.steampowered.com/IMobileAuthService/GetWGToken/v1/",
+		"form": {
+			"access_token": token
+		},
+		"json": true
+	}, function(err, response, body) {
+		if (err) {
+			callback(err);
+			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");
 };
 
 SteamCommunity.prototype.setCookies = function(cookies) {
@@ -135,46 +234,13 @@ 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", {
+	var self = this;
+
+	this.httpRequestPost("https://steamcommunity.com/parental/ajaxunlock", {
 		"json": true,
 		"form": {
 			"pin": pin
@@ -184,25 +250,30 @@ SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 			return;
 		}
 		
-		if(self._checkHttpError(err, response, callback)) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
 		if(!body || typeof body.success !== 'boolean') {
-			return callback("Invalid response");
+			callback("Invalid response");
+			return;
 		}
 		
 		if(!body.success) {
-			return callback("Incorrect PIN");
+			callback("Incorrect PIN");
+			return;
 		}
 		
 		callback();
-	}.bind(this));
+	}.bind(this), "steamcommunity");
 };
 
 SteamCommunity.prototype.getNotifications = function(callback) {
-	this.request.get("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
-		if(self._checkHttpError(err, response, callback)) {
+	var self = this;
+	this.httpRequestGet("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
+		if (err) {
+			callback(err);
 			return;
 		}
 		
@@ -232,25 +303,26 @@ SteamCommunity.prototype.getNotifications = function(callback) {
 		}
 		
 		callback(null, notifications);
-	});
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype.resetItemNotifications = function(callback) {
-	this.request.get("https://steamcommunity.com/my/inventory", function(err, response, body) {
+	var self = this;
+	this.httpRequestGet("https://steamcommunity.com/my/inventory", function(err, response, body) {
 		if(!callback) {
 			return;
 		}
-		
-		if(self._checkHttpError(err, response, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+
+		callback(err || null);
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype.loggedIn = function(callback) {
-	this.request("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
+	this.httpRequestGet({
+		"uri": "https://steamcommunity.com/my",
+		"followRedirect": false,
+		"checkHttpError": false
+	}, function(err, response, body) {
 		if(err || (response.statusCode != 302 && response.statusCode != 403)) {
 			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
@@ -262,22 +334,12 @@ SteamCommunity.prototype.loggedIn = function(callback) {
 		}
 		
 		callback(null, !!response.headers.location.match(/steamcommunity\.com(\/(id|profiles)\/[^\/]+)\/?/), false);
-	});
-};
-
-SteamCommunity.prototype._checkCommunityError = function(html, callback) {
-	if(html.match(/<h1>Sorry!<\/h1>/)) {
-		var match = html.match(/<h3>(.+)<\/h3>/);
-		callback(new Error(match ? match[1] : "Unknown error occurred"));
-		return true;
-	}
-	
-	return false;
+	}, "steamcommunity");
 };
 
 SteamCommunity.prototype._myProfile = function(endpoint, form, callback) {
 	var self = this;
-	this.request("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
+	this.httpRequest("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
 		if(err || response.statusCode != 302) {
 			callback(err || "HTTP error " + response.statusCode);
 			return;
@@ -285,33 +347,41 @@ 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;
 		}
-		
-		(form ? self.request.post : self.request)("https://steamcommunity.com" + match[1] + "/" + endpoint, form ? {"form": form} : {}, callback);
-	});
+
+		var options = {
+			"uri": "https://steamcommunity.com" + match[1] + "/" + endpoint,
+			"method": "GET"
+		};
+
+		if (form) {
+			options.method = "POST";
+			options.form = form;
+		}
+
+		self.httpRequest(options, callback, "steamcommunity");
+	}, "steamcommunity");
 };
 
-SteamCommunity.prototype._checkHttpError = function(err, response, callback) {
-	if(err) {
-		callback(err);
-		return true;
-	}
-	
-	if(response.statusCode != 200) {
-		var error = new Error("HTTP error " + response.statusCode);
-		error.code = response.statusCode;
-		callback(error);
-		return true;
-	}
-	
-	return false;
-};
 
+require('./components/http.js');
+require('./components/chat.js');
+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');
-require('./components/chat.js');
-require('./components/profile.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.3.2",
+	"version": "3.19.4",
 	"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,15 @@
 		"url": "https://github.com/DoctorMcKay/node-steamcommunity.git"
 	},
 	"dependencies": {
-		"request":			"^2.58.0",
-		"node-bignumber":	"^1.2.1",
-		"steamid":			"^0.3.0",
-		"xml2js":			"^0.4.9",
-		"cheerio":			"^0.19.0"
+		"request": "^2.61.0",
+		"node-bignumber": "^1.2.1",
+		"steamid": "^1.0.0",
+		"xml2js": "^0.4.11",
+		"cheerio": "0.19.0",
+		"async": "^1.4.2",
+		"steam-totp": "^1.3.0"
+	},
+	"engines": {
+		"node": ">=4.0.0"
 	}
-}
+}