diff --git a/Bot/IRC_Bot.cpp b/Bot/IRC_Bot.cpp
index d091203..6c3c895 100644
--- a/Bot/IRC_Bot.cpp
+++ b/Bot/IRC_Bot.cpp
@@ -47,7 +47,12 @@ IRC_Bot::IRC_Bot(const Jupiter::ReadableString &configSection) : Client(configSe
 
 IRC_Bot::~IRC_Bot()
 {
-	while (IRC_Bot::commands.size()) delete IRC_Bot::commands.remove(0);
+	if (IRCCommand::selected_server == this)
+		IRCCommand::selected_server = nullptr;
+	if (IRCCommand::active_server == this)
+		IRCCommand::active_server = IRCCommand::selected_server;
+
+	IRC_Bot::commands.emptyAndDelete();
 }
 
 void IRC_Bot::addCommand(IRCCommand *cmd)
@@ -193,9 +198,13 @@ void IRC_Bot::OnChat(const Jupiter::ReadableString &channel, const Jupiter::Read
 					IRCCommand *cmd = IRC_Bot::getCommand(command);
 					if (cmd != nullptr)
 					{
+						IRCCommand::active_server = this;
 						int cAccess = cmd->getAccessLevel(chan);
-						if (cAccess >= 0 && Jupiter::IRC::Client::getAccessLevel(channel, nick) >= cAccess) cmd->trigger(this, channel, nick, parameters);
-						else this->sendNotice(nick, STRING_LITERAL_AS_REFERENCE("Access Denied."));
+						if (cAccess >= 0 && Jupiter::IRC::Client::getAccessLevel(channel, nick) >= cAccess)
+							cmd->trigger(this, channel, nick, parameters);
+						else
+							this->sendNotice(nick, STRING_LITERAL_AS_REFERENCE("Access Denied."));
+						IRCCommand::active_server = IRCCommand::selected_server;
 					}
 				}
 			}
diff --git a/Bot/IRC_Command.cpp b/Bot/IRC_Command.cpp
index 09ad1ba..5be6158 100644
--- a/Bot/IRC_Command.cpp
+++ b/Bot/IRC_Command.cpp
@@ -53,6 +53,9 @@ IRCCommand::~IRCCommand()
 	IRCCommand::types.emptyAndDelete();
 }
 
+IRC_Bot *IRCCommand::active_server = nullptr;
+IRC_Bot *IRCCommand::selected_server = nullptr;
+
 // IRC Command Functions
 
 int IRCCommand::getAccessLevel()
diff --git a/Bot/IRC_Command.h b/Bot/IRC_Command.h
index e590de7..9fc8972 100644
--- a/Bot/IRC_Command.h
+++ b/Bot/IRC_Command.h
@@ -145,6 +145,11 @@ public:
 	*/
 	virtual ~IRCCommand();
 
+	/** Public members */
+
+	static IRC_Bot *active_server; /** Currently active IRC server */
+	static IRC_Bot *selected_server; /** Currently selected IRC server */
+
 	/** Private members */
 private:
 	int access; /** Default access level */
diff --git a/ExtraCommands/ExtraCommands.cpp b/ExtraCommands/ExtraCommands.cpp
index fa476ce..1cf4da6 100644
--- a/ExtraCommands/ExtraCommands.cpp
+++ b/ExtraCommands/ExtraCommands.cpp
@@ -20,267 +20,374 @@
 #include "ExtraCommands.h"
 #include "IRC_Bot.h"
 
-// Raw Console Command
+using namespace Jupiter::literals;
 
-RawConsoleCommand::RawConsoleCommand()
+// Select Command
+
+SelectGenericCommand::SelectGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("raw"));
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("sendraw"));
+	this->addTrigger("select"_jrs);
+	this->addTrigger("ircselect"_jrs);
 }
 
-void RawConsoleCommand::trigger(const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *SelectGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters.wordCount(WHITESPACE) < 2)
-		puts("Error: Too few parameters.");
-	else
+	if (parameters.isEmpty())
 	{
-		Jupiter::ReferenceString network = Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE);
-		Jupiter::ReferenceString message = Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE);
-		size_t total = 0;
-		for (size_t i = 0; i < serverManager->size(); i++)
-		{
-			IRC_Bot *server = serverManager->getServer(i);
-			if (server->getConfigSection().matchi(network))
-			{
-				server->send(message);
-				total++;
-			}
-		}
-		printf("%u packets sent." ENDL, total);
+		if (IRCCommand::selected_server == nullptr)
+			return new GenericCommand::ResponseLine("No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicSuccess);
+		return new GenericCommand::ResponseLine(IRCCommand::selected_server->getConfigSection() + " is currently selected."_jrs, GenericCommand::DisplayType::PublicSuccess);
 	}
+	if (IRCCommand::active_server == IRCCommand::selected_server)
+		IRCCommand::active_server = nullptr;
+
+	IRCCommand::selected_server = serverManager->getServer(parameters);
+	if (IRCCommand::selected_server == nullptr)
+		return new GenericCommand::ResponseLine("Error: IRC server \""_jrs + parameters + "\" not found. No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	if (IRCCommand::active_server == nullptr)
+		IRCCommand::active_server = IRCCommand::selected_server;
+	return new GenericCommand::ResponseLine(IRCCommand::selected_server->getConfigSection() + " is now selected."_jrs, GenericCommand::DisplayType::PublicSuccess);
 }
 
-const Jupiter::ReadableString &RawConsoleCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &SelectGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Syntax: raw <network> <message>");
+	static Jupiter::ReferenceString defaultHelp = "Selects an IRC server if specified, responds with the currently selected server otherwise. Syntax: select [server]"_jrs;
 	return defaultHelp;
 }
 
-CONSOLE_COMMAND_INIT(RawConsoleCommand)
+GENERIC_COMMAND_INIT(SelectGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(SelectGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(SelectGenericCommand, 4)
 
-// Message Console Command
+// Deselect Command
 
-MessageConsoleCommand::MessageConsoleCommand()
+DeselectGenericCommand::DeselectGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("ircmsg"));
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("message"));
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("privmsg"));
+	this->addTrigger("deselect"_jrs);
+	this->addTrigger("ircdeselect"_jrs);
+	this->addTrigger("dselect"_jrs);
+	this->addTrigger("ircdselect"_jrs);
+	this->addTrigger("unselect"_jrs);
+	this->addTrigger("ircunselect"_jrs);
 }
 
-void MessageConsoleCommand::trigger(const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *DeselectGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters.wordCount(WHITESPACE) < 3)
-		puts("Error: Too few parameters.");
+	if (IRCCommand::selected_server == nullptr)
+		return new GenericCommand::ResponseLine("No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicSuccess);
+
+	GenericCommand::ResponseLine *ret = new GenericCommand::ResponseLine(IRCCommand::selected_server->getConfigSection() + " has been deselected."_jrs, GenericCommand::DisplayType::PublicSuccess);
+	IRCCommand::selected_server = nullptr;
+	IRCCommand::active_server = IRCCommand::selected_server;
+	return ret;
+}
+
+const Jupiter::ReadableString &DeselectGenericCommand::getHelp(const Jupiter::ReadableString &)
+{
+	static Jupiter::ReferenceString defaultHelp = "Deselects the currently selected IRC server. Syntax: deselect"_jrs;
+	return defaultHelp;
+}
+
+GENERIC_COMMAND_INIT(DeselectGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(DeselectGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(DeselectGenericCommand, 4)
+
+// Raw Command
+
+RawGenericCommand::RawGenericCommand()
+{
+	this->addTrigger("raw"_jrs);
+	this->addTrigger("sendraw"_jrs);
+}
+
+GenericCommand::ResponseLine *RawGenericCommand::trigger(const Jupiter::ReadableString &parameters)
+{
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
 	else
-	{
-		Jupiter::ReferenceString network = Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE);
-		Jupiter::ReferenceString channel = Jupiter::ReferenceString::getWord(parameters, 1, WHITESPACE);
-		Jupiter::ReferenceString message = Jupiter::ReferenceString::gotoWord(parameters, 2, WHITESPACE);
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
 
-		size_t total = 0;
-		for (size_t i = 0; i < serverManager->size(); i++)
-		{
-			IRC_Bot *server = serverManager->getServer(i);
-			if (server->getConfigSection().matchi(network))
-			{
-				server->sendMessage(channel, message);
-				total++;
-			}
-		}
-		printf("%u messages sent." ENDL, total);
-	}
+	if (parameters.isEmpty())
+		return new GenericCommand::ResponseLine("Error: Too few parameters. Syntax: raw <message>"_jrs, GenericCommand::DisplayType::PrivateError);
+
+	server->send(parameters);
+	return new GenericCommand::ResponseLine("Data has been successfully sent to server."_jrs, GenericCommand::DisplayType::PublicSuccess);
 }
 
-const Jupiter::ReadableString &MessageConsoleCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &RawGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Sends a message to an IRC user/channel, on a specified network (accepts wildcards). Syntax: msg <network> <destination> <message>");
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Sends a line of data to the selected IRC server. Syntax: raw <message>");
 	return defaultHelp;
 }
 
-CONSOLE_COMMAND_INIT(MessageConsoleCommand)
+GENERIC_COMMAND_INIT(RawGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(RawGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(RawGenericCommand, 5)
+
+// Message Command
+
+IRCMessageGenericCommand::IRCMessageGenericCommand()
+{
+	this->addTrigger("ircmsg"_jrs);
+	this->addTrigger("ircmessage"_jrs);
+	this->addTrigger("privmsg"_jrs);
+}
+
+GenericCommand::ResponseLine *IRCMessageGenericCommand::trigger(const Jupiter::ReadableString &parameters)
+{
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
+	else
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	if (parameters.wordCount(WHITESPACE) < 3)
+		return new GenericCommand::ResponseLine("Error: Too few parameters. Syntax: ircmsg <destination> <message>"_jrs, GenericCommand::DisplayType::PrivateError);
+
+	server->sendMessage(Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE), Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE));
+	return new GenericCommand::ResponseLine("Message successfully sent."_jrs, GenericCommand::DisplayType::PublicSuccess);
+}
+
+const Jupiter::ReadableString &IRCMessageGenericCommand::getHelp(const Jupiter::ReadableString &)
+{
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Sends a message to an IRC user or channel on the selected IRC server. Syntax: ircmsg <destination> <message>");
+	return defaultHelp;
+}
+
+GENERIC_COMMAND_INIT(IRCMessageGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(IRCMessageGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(IRCMessageGenericCommand, 5)
 
 // Join Command
 
-void JoinIRCCommand::create()
+JoinGenericCommand::JoinGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("Join"));
-	this->setAccessLevel(3);
+	this->addTrigger("Join"_jrs);
 }
 
-void JoinIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *JoinGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters.isNotEmpty())
-	{
-		if (parameters.wordCount(WHITESPACE) == 1)
-			source->joinChannel(parameters);
-		else source->joinChannel(Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE), Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE));
-	}
-	else source->sendNotice(nick, STRING_LITERAL_AS_REFERENCE("Error: Too Few Parameters. Syntax: join <channel> [password]"));
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
+	else
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	if (parameters.isEmpty())
+		return new GenericCommand::ResponseLine("Error: Too Few Parameters. Syntax: join <channel> [password]"_jrs, GenericCommand::DisplayType::PublicError);
+
+	if (parameters.wordCount(WHITESPACE) == 1)
+		server->joinChannel(parameters);
+	else
+		server->joinChannel(Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE), Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE));
+
+	return new GenericCommand::ResponseLine("Request to join channel has been sent."_jrs, GenericCommand::DisplayType::PublicSuccess);
 }
 
-const Jupiter::ReadableString &JoinIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &JoinGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Joins a channel. Syntax: join <Channel>");
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Joins a channel. Syntax: join <channel> [password]");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(JoinIRCCommand)
+GENERIC_COMMAND_INIT(JoinGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(JoinGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(JoinGenericCommand, 3)
 
 // Part Command
 
-void PartIRCCommand::create()
+PartGenericCommand::PartGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("Part"));
-	this->setAccessLevel(3);
+	this->addTrigger("Part"_jrs);
 }
 
-void PartIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *PartGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters.isNotEmpty())
-	{
-		if (parameters.wordCount(WHITESPACE) == 1)
-			source->partChannel(parameters);
-		else source->partChannel(Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE), Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE));
-	}
-	else source->partChannel(channel);
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
+	else
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	if (parameters.isEmpty())
+		return new GenericCommand::ResponseLine("Error: Too few parameters. Syntax: part <channel> [message]"_jrs, GenericCommand::DisplayType::PublicError);
+	
+	if (parameters.wordCount(WHITESPACE) == 1)
+		server->partChannel(parameters);
+	else
+		server->partChannel(Jupiter::ReferenceString::getWord(parameters, 0, WHITESPACE), Jupiter::ReferenceString::gotoWord(parameters, 1, WHITESPACE));
+
+	return new GenericCommand::ResponseLine("Part command successfuly sent."_jrs, GenericCommand::DisplayType::PublicSuccess);
 }
 
-const Jupiter::ReadableString &PartIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &PartGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Parts from a channel. Syntax: part [channel=here] [message=empty]");
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Parts from a channel. Syntax: part <channel> [message]");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(PartIRCCommand)
+GENERIC_COMMAND_INIT(PartGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(PartGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(PartGenericCommand, 3)
 
-// Info Command
+// DebugInfo Command
 
-void InfoIRCCommand::create()
+DebugInfoGenericCommand::DebugInfoGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("info"));
-	this->setAccessLevel(4);
+	this->addTrigger("debuginfo"_jrs);
 }
 
-void InfoIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *DebugInfoGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	Jupiter::String msg;
-	msg.format("Prefixes: %.*s", source->getPrefixes().size(), source->getPrefixes().ptr());
-	source->sendMessage(channel, msg);
-	msg.format("Prefix Modes: %.*s", source->getPrefixModes().size(), source->getPrefixModes().ptr());
-	source->sendMessage(channel, msg);
-	msg.format("Outputing data for %u channels...", source->getChannelCount());
-	source->sendMessage(channel, msg);
-	for (unsigned int a = 0; a < source->getChannelCount(); a++)
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
+	else
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	Jupiter::IRC::Client::Channel *chan;
+	Jupiter::IRC::Client::User *user;
+	GenericCommand::ResponseLine *ret = new GenericCommand::ResponseLine("Prefixes: "_jrs + server->getPrefixes(), GenericCommand::DisplayType::PublicSuccess);
+	GenericCommand::ResponseLine *line = new GenericCommand::ResponseLine("Prefix Modes: "_jrs + server->getPrefixModes(), GenericCommand::DisplayType::PublicSuccess);
+	ret->next = line;
+	line->next = new GenericCommand::ResponseLine(Jupiter::StringS::Format("Outputting data for %u channels...", server->getChannelCount()), GenericCommand::DisplayType::PublicSuccess);
+	line = line->next;
+	for (unsigned int index = 0; index < server->getChannelCount(); ++index)
 	{
-		Jupiter::IRC::Client::Channel *chan = source->getChannel(a);
+		chan = server->getChannel(index);
 		if (chan != nullptr)
 		{
-			msg.format("Channel %.*s - Type: %d", chan->getName().size(), chan->getName().ptr(), chan->getType());
-			source->sendMessage(channel, msg);
-			for (unsigned int b = 0; b < chan->getUserCount(); b++)
+			line->next = new GenericCommand::ResponseLine(Jupiter::StringS::Format("Channel %.*s - Type: %d", chan->getName().size(), chan->getName().ptr(), chan->getType()), GenericCommand::DisplayType::PublicSuccess);
+			line = line->next;
+			for (unsigned int j = 0; j != chan->getUserCount(); ++j)
 			{
-				Jupiter::IRC::Client::Channel::User *chanUser = chan->getUser(b);
-				Jupiter::IRC::Client::User *user = chanUser->getUser();
-				msg.format("PRIVMSG %.*s :User %.*s!%.*s@%.*s (prefix: %c) of channel %.*s (of %u shared)" ENDL, channel.size(), channel.ptr(), user->getNickname().size(), user->getNickname().ptr(), user->getUsername().size(), user->getUsername().ptr(), user->getHostname().size(), user->getHostname().ptr(), chan->getUserPrefix(b) ? chan->getUserPrefix(b) : ' ', chan->getName().size(), chan->getName().ptr(), user->getChannelCount());
-				source->send(msg);
+				user = chan->getUser(j)->getUser();
+				line->next = new GenericCommand::ResponseLine(Jupiter::StringS::Format("User %.*s!%.*s@%.*s (prefix: %c) of channel %.*s (of %u shared)", user->getNickname().size(), user->getNickname().ptr(), user->getUsername().size(), user->getUsername().ptr(), user->getHostname().size(), user->getHostname().ptr(), chan->getUserPrefix(j) ? chan->getUserPrefix(j) : ' ', chan->getName().size(), chan->getName().ptr(), user->getChannelCount()), GenericCommand::DisplayType::PublicSuccess);
+				line = line->next;
 			}
 		}
 	}
+	return ret;
 }
 
-const Jupiter::ReadableString &InfoIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &DebugInfoGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "TEMPORARY COMMAND - Spits out some info about channels. Syntax: info");
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "DEBUG COMMAND - Spits out some information about channels. Syntax: debuginfo");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(InfoIRCCommand)
+GENERIC_COMMAND_INIT(DebugInfoGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(DebugInfoGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(DebugInfoGenericCommand, 4)
 
 // Exit command
 
-void ExitIRCCommand::create()
+ExitGenericCommand::ExitGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("exit"));
-	this->setAccessLevel(5);
+	this->addTrigger("exit"_jrs);
 }
 
-void ExitIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *ExitGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	source->sendMessage(channel, STRING_LITERAL_AS_REFERENCE("Bye!"));
 	exit(0);
 }
 
-const Jupiter::ReadableString &ExitIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &ExitGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
 	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Closes the bot's application process. Syntax: exit");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(ExitIRCCommand)
+GENERIC_COMMAND_INIT(ExitGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(ExitGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(ExitGenericCommand, 5)
 
 // IRC Connect command
 
-void IRCConnectIRCCommand::create()
+IRCConnectGenericCommand::IRCConnectGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("IRCConnect"));
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("IRCReconnect"));
-	this->setAccessLevel(5);
+	this->addTrigger("IRCConnect"_jrs);
+	this->addTrigger("IRCReconnect"_jrs);
 }
 
-void IRCConnectIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *IRCConnectGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters == nullptr)
-		source->disconnect(STRING_LITERAL_AS_REFERENCE("Connect command used; reconnecting..."), false);
-	else
+	if (parameters.isEmpty())
 	{
-		IRC_Bot *server = serverManager->getServer(parameters);
-		if (server != nullptr)
-		{
-			source->sendMessage(channel, STRING_LITERAL_AS_REFERENCE("Warning: Server already exists. Severing connection..."));
-			server->disconnect(true);
-		}
-		if (serverManager->addServer(parameters))
-			source->sendMessage(channel, STRING_LITERAL_AS_REFERENCE("Connection successfully established; server added to server list."));
-		else source->sendMessage(channel, STRING_LITERAL_AS_REFERENCE("Error: Unable to find configuration settings for server, or connection refused."));
+		IRC_Bot *server;
+		if (IRCCommand::selected_server != nullptr)
+			server = IRCCommand::selected_server;
+		else if (IRCCommand::active_server != nullptr)
+			server = IRCCommand::active_server;
+		else
+			return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+		server->disconnect("Connect command used; reconnecting..."_jrs, false);
+		return new GenericCommand::ResponseLine("Disconnected from IRC server."_jrs, GenericCommand::DisplayType::PublicSuccess);
+	}
+	IRC_Bot *server = serverManager->getServer(parameters);
+	if (server != nullptr)
+	{
+		server->disconnect("Connect command used; reconnecting..."_jrs, false);
+		return new GenericCommand::ResponseLine("Disconnected from IRC server."_jrs, GenericCommand::DisplayType::PublicSuccess);
 	}
+	if (serverManager->addServer(parameters))
+		return new GenericCommand::ResponseLine("Connection successfully established; server added to server list."_jrs, GenericCommand::DisplayType::PublicSuccess);
+	return new GenericCommand::ResponseLine("Error: Unable to find configuration settings for server, or connection refused."_jrs, GenericCommand::DisplayType::PublicError);
 }
 
-const Jupiter::ReadableString &IRCConnectIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &IRCConnectGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
 	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Connects/reconnects to an IRC server, based on config entry. Syntax: IRCConnect [server=here]");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(IRCConnectIRCCommand)
+GENERIC_COMMAND_INIT(IRCConnectGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(IRCConnectGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(IRCConnectGenericCommand, 5)
 
 // IRC Disconnect command
 
-void IRCDisconnectIRCCommand::create()
+IRCDisconnectGenericCommand::IRCDisconnectGenericCommand()
 {
-	this->addTrigger(STRING_LITERAL_AS_REFERENCE("IRCDisconnect"));
-	this->setAccessLevel(5);
+	this->addTrigger("IRCDisconnect"_jrs);
 }
 
-void IRCDisconnectIRCCommand::trigger(IRC_Bot *source, const Jupiter::ReadableString &channel, const Jupiter::ReadableString &nick, const Jupiter::ReadableString &parameters)
+GenericCommand::ResponseLine *IRCDisconnectGenericCommand::trigger(const Jupiter::ReadableString &parameters)
 {
-	if (parameters.isEmpty())
-		source->disconnect(STRING_LITERAL_AS_REFERENCE("Disconnect command used"), true);
+	IRC_Bot *server;
+	if (IRCCommand::selected_server != nullptr)
+		server = IRCCommand::selected_server;
+	else if (IRCCommand::active_server != nullptr)
+		server = IRCCommand::active_server;
 	else
-	{
-		IRC_Bot *server = serverManager->getServer(parameters);
-		if (server == nullptr)
-			source->sendNotice(nick, STRING_LITERAL_AS_REFERENCE("Error: Server not found."));
-		else server->disconnect(STRING_LITERAL_AS_REFERENCE("Disconnect command used remotely"), true);
-	}
+		return new GenericCommand::ResponseLine("Error: No IRC server is currently selected."_jrs, GenericCommand::DisplayType::PublicError);
+
+	server->disconnect("Disconnect command used."_jrs, true);
+	return new GenericCommand::ResponseLine("Disconnected from server."_jrs, GenericCommand::DisplayType::PublicSuccess);
 }
 
-const Jupiter::ReadableString &IRCDisconnectIRCCommand::getHelp(const Jupiter::ReadableString &)
+const Jupiter::ReadableString &IRCDisconnectGenericCommand::getHelp(const Jupiter::ReadableString &)
 {
-	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Disconnects from an IRC server, based on config entry. Syntax: IRCDisconnect [server=here]");
+	static STRING_LITERAL_AS_NAMED_REFERENCE(defaultHelp, "Disconnects from an IRC server, based on config entry. Syntax: IRCDisconnect");
 	return defaultHelp;
 }
 
-IRC_COMMAND_INIT(IRCDisconnectIRCCommand)
+GENERIC_COMMAND_INIT(IRCDisconnectGenericCommand)
+GENERIC_COMMAND_AS_CONSOLE_COMMAND(IRCDisconnectGenericCommand)
+GENERIC_COMMAND_AS_IRC_COMMAND_ACCESS_CREATE(IRCDisconnectGenericCommand, 5)
 
 // Plugin instantiation and entry point.
 FunCommandsPlugin pluginInstance;
diff --git a/ExtraCommands/ExtraCommands.h b/ExtraCommands/ExtraCommands.h
index 08a80d2..b75f512 100644
--- a/ExtraCommands/ExtraCommands.h
+++ b/ExtraCommands/ExtraCommands.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2014 Justin James.
+ * Copyright (C) 2014-2015 Justin James.
  *
  * This license must be preserved.
  * Any applications, libraries, or code which make any use of any
@@ -31,13 +31,15 @@ private:
 	STRING_LITERAL_AS_NAMED_REFERENCE(name, "ExtraCommands");
 };
 
-GENERIC_CONSOLE_COMMAND(RawConsoleCommand)
-GENERIC_CONSOLE_COMMAND(MessageConsoleCommand)
-GENERIC_IRC_COMMAND(JoinIRCCommand)
-GENERIC_IRC_COMMAND(PartIRCCommand)
-GENERIC_IRC_COMMAND(InfoIRCCommand)
-GENERIC_IRC_COMMAND(ExitIRCCommand)
-GENERIC_IRC_COMMAND(IRCConnectIRCCommand)
-GENERIC_IRC_COMMAND(IRCDisconnectIRCCommand)
+GENERIC_GENERIC_COMMAND(SelectGenericCommand)
+GENERIC_GENERIC_COMMAND(DeselectGenericCommand)
+GENERIC_GENERIC_COMMAND(RawGenericCommand)
+GENERIC_GENERIC_COMMAND(IRCMessageGenericCommand)
+GENERIC_GENERIC_COMMAND(JoinGenericCommand)
+GENERIC_GENERIC_COMMAND(PartGenericCommand)
+GENERIC_GENERIC_COMMAND(DebugInfoGenericCommand)
+GENERIC_GENERIC_COMMAND(ExitGenericCommand)
+GENERIC_GENERIC_COMMAND(IRCConnectGenericCommand)
+GENERIC_GENERIC_COMMAND(IRCDisconnectGenericCommand)
 
 #endif // _EXTRACOMMANDS_H_HEADER
\ No newline at end of file
diff --git a/Release/Bot.lib b/Release/Bot.lib
index 71c83c1..a164183 100644
Binary files a/Release/Bot.lib and b/Release/Bot.lib differ
diff --git a/Release/Plugins/RenX.Core.lib b/Release/Plugins/RenX.Core.lib
index 1160e05..3d2f4a4 100644
Binary files a/Release/Plugins/RenX.Core.lib and b/Release/Plugins/RenX.Core.lib differ