Move command logic into app layer (#5617)

26 files changed, 809 insertions, 712 deletions

diff --git a/api/command.go b/api/command.go
index c3a64702f..2248caf76 100644
--- a/api/command.go
+++ b/api/command.go
@@ -4,11 +4,8 @@
 package api
 
 import (
-	"crypto/tls"
-	"fmt"
 	"io/ioutil"
 	"net/http"
-	"net/url"
 	"strings"
 
 	l4g "github.com/alecthomas/log4go"
@@ -18,27 +15,6 @@ import (
 	"github.com/mattermost/platform/utils"
 )
 
-type CommandProvider interface {
-	GetTrigger() string
-	GetCommand(c *Context) *model.Command
-	DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse
-}
-
-var commandProviders = make(map[string]CommandProvider)
-
-func RegisterCommandProvider(newProvider CommandProvider) {
-	commandProviders[newProvider.GetTrigger()] = newProvider
-}
-
-func GetCommandProvider(name string) CommandProvider {
-	provider, ok := commandProviders[name]
-	if ok {
-		return provider
-	}
-
-	return nil
-}
-
 func InitCommand() {
 	l4g.Debug(utils.T("api.command.init.debug"))
 
@@ -58,31 +34,10 @@ func InitCommand() {
 }
 
 func listCommands(c *Context, w http.ResponseWriter, r *http.Request) {
-	commands := make([]*model.Command, 0, 32)
-	seen := make(map[string]bool)
-	for _, value := range commandProviders {
-		cpy := *value.GetCommand(c)
-		if cpy.AutoComplete && !seen[cpy.Id] {
-			cpy.Sanitize()
-			seen[cpy.Trigger] = true
-			commands = append(commands, &cpy)
-		}
-	}
-
-	if *utils.Cfg.ServiceSettings.EnableCommands {
-		if result := <-app.Srv.Store.Command().GetByTeam(c.TeamId); result.Err != nil {
-			c.Err = result.Err
-			return
-		} else {
-			teamCmds := result.Data.([]*model.Command)
-			for _, cmd := range teamCmds {
-				if cmd.AutoComplete && !seen[cmd.Id] {
-					cmd.Sanitize()
-					seen[cmd.Trigger] = true
-					commands = append(commands, cmd)
-				}
-			}
-		}
+	commands, err := app.ListCommands(c.TeamId, c.T)
+	if err != nil {
+		c.Err = err
+		return
 	}
 
 	w.Write([]byte(model.CommandListToJson(commands)))
@@ -90,9 +45,13 @@ func listCommands(c *Context, w http.ResponseWriter, r *http.Request) {
 
 func executeCommand(c *Context, w http.ResponseWriter, r *http.Request) {
 	commandArgs := model.CommandArgsFromJson(r.Body)
+	if commandArgs == nil {
+		c.SetInvalidParam("executeCommand", "command_args")
+		return
+	}
 
 	if len(commandArgs.Command) <= 1 || strings.Index(commandArgs.Command, "/") != 0 {
-		c.Err = model.NewLocAppError("executeCommand", "api.command.execute_command.start.app_error", nil, "")
+		c.Err = model.NewAppError("executeCommand", "api.command.execute_command.start.app_error", nil, "", http.StatusBadRequest)
 		return
 	}
 
@@ -103,232 +62,50 @@ func executeCommand(c *Context, w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	parts := strings.Split(commandArgs.Command, " ")
-	trigger := parts[0][1:]
-	trigger = strings.ToLower(trigger)
-	message := strings.Join(parts[1:], " ")
-	provider := GetCommandProvider(trigger)
-
-	if provider != nil {
-		response := provider.DoCommand(c, commandArgs, message)
-		handleResponse(c, w, response, commandArgs, provider.GetCommand(c), true)
-		return
-	} else {
-
-		if !*utils.Cfg.ServiceSettings.EnableCommands {
-			c.Err = model.NewLocAppError("executeCommand", "api.command.disabled.app_error", nil, "")
-			c.Err.StatusCode = http.StatusNotImplemented
-			return
-		}
-
-		chanChan := app.Srv.Store.Channel().Get(commandArgs.ChannelId, true)
-		teamChan := app.Srv.Store.Team().Get(c.TeamId)
-		userChan := app.Srv.Store.User().Get(c.Session.UserId)
-
-		if result := <-app.Srv.Store.Command().GetByTeam(c.TeamId); result.Err != nil {
-			c.Err = result.Err
-			return
-		} else {
-
-			var team *model.Team
-			if tr := <-teamChan; tr.Err != nil {
-				c.Err = tr.Err
-				return
-			} else {
-				team = tr.Data.(*model.Team)
-			}
-
-			var user *model.User
-			if ur := <-userChan; ur.Err != nil {
-				c.Err = ur.Err
-				return
-			} else {
-				user = ur.Data.(*model.User)
-			}
-
-			var channel *model.Channel
-			if cr := <-chanChan; cr.Err != nil {
-				c.Err = cr.Err
-				return
-			} else {
-				channel = cr.Data.(*model.Channel)
-			}
-
-			teamCmds := result.Data.([]*model.Command)
-			for _, cmd := range teamCmds {
-				if trigger == cmd.Trigger {
-					l4g.Debug(fmt.Sprintf(utils.T("api.command.execute_command.debug"), trigger, c.Session.UserId))
-
-					p := url.Values{}
-					p.Set("token", cmd.Token)
-
-					p.Set("team_id", cmd.TeamId)
-					p.Set("team_domain", team.Name)
-
-					p.Set("channel_id", commandArgs.ChannelId)
-					p.Set("channel_name", channel.Name)
-
-					p.Set("user_id", c.Session.UserId)
-					p.Set("user_name", user.Username)
-
-					p.Set("command", "/"+trigger)
-					p.Set("text", message)
-					p.Set("response_url", "not supported yet")
-
-					method := "POST"
-					if cmd.Method == model.COMMAND_METHOD_GET {
-						method = "GET"
-					}
-
-					tr := &http.Transport{
-						TLSClientConfig: &tls.Config{InsecureSkipVerify: *utils.Cfg.ServiceSettings.EnableInsecureOutgoingConnections},
-					}
-					client := &http.Client{Transport: tr}
-
-					req, _ := http.NewRequest(method, cmd.URL, strings.NewReader(p.Encode()))
-					req.Header.Set("Accept", "application/json")
-					if cmd.Method == model.COMMAND_METHOD_POST {
-						req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-					}
-
-					if resp, err := client.Do(req); err != nil {
-						c.Err = model.NewLocAppError("command", "api.command.execute_command.failed.app_error", map[string]interface{}{"Trigger": trigger}, err.Error())
-					} else {
-						if resp.StatusCode == http.StatusOK {
-							response := model.CommandResponseFromJson(resp.Body)
-							if response == nil {
-								c.Err = model.NewLocAppError("command", "api.command.execute_command.failed_empty.app_error", map[string]interface{}{"Trigger": trigger}, "")
-							} else {
-								handleResponse(c, w, response, commandArgs, cmd, false)
-							}
-						} else {
-							defer resp.Body.Close()
-							body, _ := ioutil.ReadAll(resp.Body)
-							c.Err = model.NewLocAppError("command", "api.command.execute_command.failed_resp.app_error", map[string]interface{}{"Trigger": trigger, "Status": resp.Status}, string(body))
-						}
-					}
-
-					return
-				}
-			}
-
-		}
-	}
-
-	c.Err = model.NewLocAppError("command", "api.command.execute_command.not_found.app_error", map[string]interface{}{"Trigger": trigger}, "")
-}
+	commandArgs.TeamId = c.TeamId
+	commandArgs.UserId = c.Session.UserId
+	commandArgs.T = c.T
+	commandArgs.Session = c.Session
+	commandArgs.SiteURL = c.GetSiteURL()
 
-func handleResponse(c *Context, w http.ResponseWriter, response *model.CommandResponse, commandArgs *model.CommandArgs, cmd *model.Command, builtIn bool) {
-	if c.Err != nil {
+	response, err := app.ExecuteCommand(commandArgs)
+	if err != nil {
+		c.Err = err
 		return
 	}
 
-	post := &model.Post{}
-	post.ChannelId = commandArgs.ChannelId
-	post.RootId = commandArgs.RootId
-	post.ParentId = commandArgs.ParentId
-	post.UserId = c.Session.UserId
-
-	if !builtIn {
-		post.AddProp("from_webhook", "true")
-	}
-
-	if utils.Cfg.ServiceSettings.EnablePostUsernameOverride {
-		if len(cmd.Username) != 0 {
-			post.AddProp("override_username", cmd.Username)
-		} else if len(response.Username) != 0 {
-			post.AddProp("override_username", response.Username)
-		}
-	}
-
-	if utils.Cfg.ServiceSettings.EnablePostIconOverride {
-		if len(cmd.IconURL) != 0 {
-			post.AddProp("override_icon_url", cmd.IconURL)
-		} else if len(response.IconURL) != 0 {
-			post.AddProp("override_icon_url", response.IconURL)
-		} else {
-			post.AddProp("override_icon_url", "")
-		}
-	}
-
-	if _, err := app.CreateCommandPost(post, c.TeamId, response); err != nil {
-		l4g.Error(err.Error())
-	}
-
 	w.Write([]byte(response.ToJson()))
 }
 
 func createCommand(c *Context, w http.ResponseWriter, r *http.Request) {
-	if !*utils.Cfg.ServiceSettings.EnableCommands {
-		c.Err = model.NewLocAppError("createCommand", "api.command.disabled.app_error", nil, "")
-		c.Err.StatusCode = http.StatusNotImplemented
-		return
-	}
+	cmd := model.CommandFromJson(r.Body)
 
-	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
-		c.Err = model.NewLocAppError("createCommand", "api.command.admin_only.app_error", nil, "")
-		c.Err.StatusCode = http.StatusForbidden
+	if cmd == nil {
+		c.SetInvalidParam("createCommand", "command")
 		return
 	}
 
 	c.LogAudit("attempt")
 
-	cmd := model.CommandFromJson(r.Body)
-
-	if cmd == nil {
-		c.SetInvalidParam("createCommand", "command")
+	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
+		c.SetPermissionError(model.PERMISSION_MANAGE_SLASH_COMMANDS)
 		return
 	}
 
-	cmd.Trigger = strings.ToLower(cmd.Trigger)
 	cmd.CreatorId = c.Session.UserId
 	cmd.TeamId = c.TeamId
 
-	if result := <-app.Srv.Store.Command().GetByTeam(c.TeamId); result.Err != nil {
-		c.Err = result.Err
+	rcmd, err := app.CreateCommand(cmd)
+	if err != nil {
+		c.Err = err
 		return
-	} else {
-		teamCmds := result.Data.([]*model.Command)
-		for _, existingCommand := range teamCmds {
-			if cmd.Trigger == existingCommand.Trigger {
-				c.Err = model.NewLocAppError("createCommand", "api.command.duplicate_trigger.app_error", nil, "")
-				return
-			}
-		}
-		for _, builtInProvider := range commandProviders {
-			builtInCommand := *builtInProvider.GetCommand(c)
-			if cmd.Trigger == builtInCommand.Trigger {
-				c.Err = model.NewLocAppError("createCommand", "api.command.duplicate_trigger.app_error", nil, "")
-				return
-			}
-		}
 	}
 
-	if result := <-app.Srv.Store.Command().Save(cmd); result.Err != nil {
-		c.Err = result.Err
-		return
-	} else {
-		c.LogAudit("success")
-		rcmd := result.Data.(*model.Command)
-		w.Write([]byte(rcmd.ToJson()))
-	}
+	c.LogAudit("success")
+	w.Write([]byte(rcmd.ToJson()))
 }
 
 func updateCommand(c *Context, w http.ResponseWriter, r *http.Request) {
-	if !*utils.Cfg.ServiceSettings.EnableCommands {
-		c.Err = model.NewLocAppError("updateCommand", "api.command.disabled.app_error", nil, "")
-		c.Err.StatusCode = http.StatusNotImplemented
-		return
-	}
-
-	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
-		c.Err = model.NewLocAppError("updateCommand", "api.command.admin_only.app_error", nil, "")
-		c.Err.StatusCode = http.StatusForbidden
-		return
-	}
-
-	c.LogAudit("attempt")
-
 	cmd := model.CommandFromJson(r.Body)
 
 	if cmd == nil {
@@ -336,80 +113,58 @@ func updateCommand(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	cmd.Trigger = strings.ToLower(cmd.Trigger)
+	c.LogAudit("attempt")
 
-	var oldCmd *model.Command
-	if result := <-app.Srv.Store.Command().Get(cmd.Id); result.Err != nil {
-		c.Err = result.Err
+	oldCmd, err := app.GetCommand(cmd.Id)
+	if err != nil {
+		c.Err = err
 		return
-	} else {
-		oldCmd = result.Data.(*model.Command)
-
-		if c.Session.UserId != oldCmd.CreatorId && !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS) {
-			c.LogAudit("fail - inappropriate permissions")
-			c.Err = model.NewLocAppError("updateCommand", "api.command.update.app_error", nil, "user_id="+c.Session.UserId)
-			return
-		}
-
-		if c.TeamId != oldCmd.TeamId {
-			c.Err = model.NewLocAppError("updateCommand", "api.command.team_mismatch.app_error", nil, "user_id="+c.Session.UserId)
-			return
-		}
-
-		cmd.Id = oldCmd.Id
-		cmd.Token = oldCmd.Token
-		cmd.CreateAt = oldCmd.CreateAt
-		cmd.UpdateAt = model.GetMillis()
-		cmd.DeleteAt = oldCmd.DeleteAt
-		cmd.CreatorId = oldCmd.CreatorId
-		cmd.TeamId = oldCmd.TeamId
 	}
 
-	if result := <-app.Srv.Store.Command().Update(cmd); result.Err != nil {
-		c.Err = result.Err
+	if c.TeamId != oldCmd.TeamId {
+		c.Err = model.NewAppError("updateCommand", "api.command.team_mismatch.app_error", nil, "user_id="+c.Session.UserId, http.StatusBadRequest)
 		return
-	} else {
-		w.Write([]byte(result.Data.(*model.Command).ToJson()))
 	}
-}
 
-func listTeamCommands(c *Context, w http.ResponseWriter, r *http.Request) {
-	if !*utils.Cfg.ServiceSettings.EnableCommands {
-		c.Err = model.NewLocAppError("listTeamCommands", "api.command.disabled.app_error", nil, "")
-		c.Err.StatusCode = http.StatusNotImplemented
+	if !app.SessionHasPermissionToTeam(c.Session, oldCmd.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
+		c.LogAudit("fail - inappropriate permissions")
+		c.SetPermissionError(model.PERMISSION_MANAGE_SLASH_COMMANDS)
 		return
 	}
 
-	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
-		c.Err = model.NewLocAppError("listTeamCommands", "api.command.admin_only.app_error", nil, "")
-		c.Err.StatusCode = http.StatusForbidden
+	if c.Session.UserId != oldCmd.CreatorId && !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS) {
+		c.LogAudit("fail - inappropriate permissions")
+		c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS)
 		return
 	}
 
-	if result := <-app.Srv.Store.Command().GetByTeam(c.TeamId); result.Err != nil {
-		c.Err = result.Err
+	rcmd, err := app.UpdateCommand(oldCmd, cmd)
+	if err != nil {
+		c.Err = err
 		return
-	} else {
-		cmds := result.Data.([]*model.Command)
-		w.Write([]byte(model.CommandListToJson(cmds)))
 	}
+
+	c.LogAudit("success")
+
+	w.Write([]byte(rcmd.ToJson()))
 }
 
-func regenCommandToken(c *Context, w http.ResponseWriter, r *http.Request) {
-	if !*utils.Cfg.ServiceSettings.EnableCommands {
-		c.Err = model.NewLocAppError("regenCommandToken", "api.command.disabled.app_error", nil, "")
-		c.Err.StatusCode = http.StatusNotImplemented
+func listTeamCommands(c *Context, w http.ResponseWriter, r *http.Request) {
+	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
+		c.SetPermissionError(model.PERMISSION_MANAGE_SLASH_COMMANDS)
 		return
 	}
 
-	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
-		c.Err = model.NewLocAppError("regenCommandToken", "api.command.admin_only.app_error", nil, "")
-		c.Err.StatusCode = http.StatusForbidden
+	cmds, err := app.ListTeamCommands(c.TeamId)
+	if err != nil {
+		c.Err = err
 		return
 	}
 
-	c.LogAudit("attempt")
+	w.Write([]byte(model.CommandListToJson(cmds)))
+}
 
+func regenCommandToken(c *Context, w http.ResponseWriter, r *http.Request) {
 	props := model.MapFromJson(r.Body)
 
 	id := props["id"]
@@ -418,45 +173,41 @@ func regenCommandToken(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var cmd *model.Command
-	if result := <-app.Srv.Store.Command().Get(id); result.Err != nil {
-		c.Err = result.Err
-		return
-	} else {
-		cmd = result.Data.(*model.Command)
+	c.LogAudit("attempt")
 
-		if c.TeamId != cmd.TeamId || (c.Session.UserId != cmd.CreatorId && !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS)) {
-			c.LogAudit("fail - inappropriate permissions")
-			c.Err = model.NewLocAppError("regenToken", "api.command.regen.app_error", nil, "user_id="+c.Session.UserId)
-			return
-		}
+	cmd, err := app.GetCommand(id)
+	if err != nil {
+		c.Err = err
+		return
 	}
 
-	cmd.Token = model.NewId()
+	if c.TeamId != cmd.TeamId {
+		c.Err = model.NewAppError("regenCommandToken", "api.command.team_mismatch.app_error", nil, "user_id="+c.Session.UserId, http.StatusBadRequest)
+		return
+	}
 
-	if result := <-app.Srv.Store.Command().Update(cmd); result.Err != nil {
-		c.Err = result.Err
+	if !app.SessionHasPermissionToTeam(c.Session, cmd.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
+		c.LogAudit("fail - inappropriate permissions")
+		c.SetPermissionError(model.PERMISSION_MANAGE_SLASH_COMMANDS)
 		return
-	} else {
-		w.Write([]byte(result.Data.(*model.Command).ToJson()))
 	}
-}
 
-func deleteCommand(c *Context, w http.ResponseWriter, r *http.Request) {
-	if !*utils.Cfg.ServiceSettings.EnableCommands {
-		c.Err = model.NewLocAppError("deleteCommand", "api.command.disabled.app_error", nil, "")
-		c.Err.StatusCode = http.StatusNotImplemented
+	if c.Session.UserId != cmd.CreatorId && !app.SessionHasPermissionToTeam(c.Session, cmd.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS) {
+		c.LogAudit("fail - inappropriate permissions")
+		c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS)
 		return
 	}
 
-	if !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
-		c.Err = model.NewLocAppError("deleteCommand", "api.command.admin_only.app_error", nil, "")
-		c.Err.StatusCode = http.StatusForbidden
+	rcmd, err := app.RegenCommandToken(cmd)
+	if err != nil {
+		c.Err = err
 		return
 	}
 
-	c.LogAudit("attempt")
+	w.Write([]byte(rcmd.ToJson()))
+}
 
+func deleteCommand(c *Context, w http.ResponseWriter, r *http.Request) {
 	props := model.MapFromJson(r.Body)
 
 	id := props["id"]
@@ -465,18 +216,33 @@ func deleteCommand(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if result := <-app.Srv.Store.Command().Get(id); result.Err != nil {
-		c.Err = result.Err
+	c.LogAudit("attempt")
+
+	cmd, err := app.GetCommand(id)
+	if err != nil {
+		c.Err = err
+		return
+	}
+
+	if c.TeamId != cmd.TeamId {
+		c.Err = model.NewAppError("deleteCommand", "api.command.team_mismatch.app_error", nil, "user_id="+c.Session.UserId, http.StatusBadRequest)
+		return
+	}
+
+	if !app.SessionHasPermissionToTeam(c.Session, cmd.TeamId, model.PERMISSION_MANAGE_SLASH_COMMANDS) {
+		c.SetPermissionError(model.PERMISSION_MANAGE_SLASH_COMMANDS)
+		c.LogAudit("fail - inappropriate permissions")
+		return
+	}
+
+	if c.Session.UserId != cmd.CreatorId && !app.SessionHasPermissionToTeam(c.Session, cmd.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS) {
+		c.SetPermissionError(model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS)
+		c.LogAudit("fail - inappropriate permissions")
 		return
-	} else {
-		if c.TeamId != result.Data.(*model.Command).TeamId || (c.Session.UserId != result.Data.(*model.Command).CreatorId && !app.SessionHasPermissionToTeam(c.Session, c.TeamId, model.PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS)) {
-			c.LogAudit("fail - inappropriate permissions")
-			c.Err = model.NewLocAppError("deleteCommand", "api.command.delete.app_error", nil, "user_id="+c.Session.UserId)
-			return
-		}
 	}
 
-	if err := (<-app.Srv.Store.Command().Delete(id, model.GetMillis())).Err; err != nil {
+	err = app.DeleteCommand(cmd.Id)
+	if err != nil {
 		c.Err = err
 		return
 	}
diff --git a/api/command_expand_collapse.go b/api/command_expand_collapse.go
deleted file mode 100644
index 5adbf4bab..000000000
--- a/api/command_expand_collapse.go
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package api
-
-import (
-	"strconv"
-
-	"github.com/mattermost/platform/app"
-	"github.com/mattermost/platform/model"
-)
-
-type ExpandProvider struct {
-}
-
-type CollapseProvider struct {
-}
-
-const (
-	CMD_EXPAND   = "expand"
-	CMD_COLLAPSE = "collapse"
-)
-
-func init() {
-	RegisterCommandProvider(&ExpandProvider{})
-	RegisterCommandProvider(&CollapseProvider{})
-}
-
-func (me *ExpandProvider) GetTrigger() string {
-	return CMD_EXPAND
-}
-
-func (me *CollapseProvider) GetTrigger() string {
-	return CMD_COLLAPSE
-}
-
-func (me *ExpandProvider) GetCommand(c *Context) *model.Command {
-	return &model.Command{
-		Trigger:          CMD_EXPAND,
-		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_expand.desc"),
-		DisplayName:      c.T("api.command_expand.name"),
-	}
-}
-
-func (me *CollapseProvider) GetCommand(c *Context) *model.Command {
-	return &model.Command{
-		Trigger:          CMD_COLLAPSE,
-		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_collapse.desc"),
-		DisplayName:      c.T("api.command_collapse.name"),
-	}
-}
-
-func (me *ExpandProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	return setCollapsePreference(c, false)
-}
-
-func (me *CollapseProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	return setCollapsePreference(c, true)
-}
-
-func setCollapsePreference(c *Context, isCollapse bool) *model.CommandResponse {
-	pref := model.Preference{
-		UserId:   c.Session.UserId,
-		Category: model.PREFERENCE_CATEGORY_DISPLAY_SETTINGS,
-		Name:     model.PREFERENCE_NAME_COLLAPSE_SETTING,
-		Value:    strconv.FormatBool(isCollapse),
-	}
-
-	if result := <-app.Srv.Store.Preference().Save(&model.Preferences{pref}); result.Err != nil {
-		return &model.CommandResponse{Text: c.T("api.command_expand_collapse.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	}
-
-	socketMessage := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_PREFERENCE_CHANGED, "", "", c.Session.UserId, nil)
-	socketMessage.Add("preference", pref.ToJson())
-	go app.Publish(socketMessage)
-
-	var rmsg string
-
-	if isCollapse {
-		rmsg = c.T("api.command_collapse.success")
-	} else {
-		rmsg = c.T("api.command_expand.success")
-	}
-	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: rmsg}
-}
diff --git a/api/command_join.go b/api/command_join.go
deleted file mode 100644
index 17deb02b7..000000000
--- a/api/command_join.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package api
-
-import (
-	"github.com/mattermost/platform/app"
-	"github.com/mattermost/platform/model"
-)
-
-type JoinProvider struct {
-}
-
-const (
-	CMD_JOIN = "join"
-)
-
-func init() {
-	RegisterCommandProvider(&JoinProvider{})
-}
-
-func (me *JoinProvider) GetTrigger() string {
-	return CMD_JOIN
-}
-
-func (me *JoinProvider) GetCommand(c *Context) *model.Command {
-	return &model.Command{
-		Trigger:          CMD_JOIN,
-		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_join.desc"),
-		AutoCompleteHint: c.T("api.command_join.hint"),
-		DisplayName:      c.T("api.command_join.name"),
-	}
-}
-
-func (me *JoinProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	if result := <-app.Srv.Store.Channel().GetByName(c.TeamId, message, true); result.Err != nil {
-		return &model.CommandResponse{Text: c.T("api.command_join.list.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	} else {
-		channel := result.Data.(*model.Channel)
-
-		if channel.Name == message {
-
-			if channel.Type != model.CHANNEL_OPEN {
-				return &model.CommandResponse{Text: c.T("api.command_join.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-			}
-
-			if err := app.JoinChannel(channel, c.Session.UserId); err != nil {
-				return &model.CommandResponse{Text: c.T("api.command_join.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-			}
-
-			return &model.CommandResponse{GotoLocation: c.GetTeamURL() + "/channels/" + channel.Name, Text: c.T("api.command_join.success"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-		}
-	}
-
-	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command_join.missing.app_error")}
-}
diff --git a/api/command_msg.go b/api/command_msg.go
deleted file mode 100644
index f8c8fae1c..000000000
--- a/api/command_msg.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package api
-
-import (
-	"strings"
-
-	l4g "github.com/alecthomas/log4go"
-	"github.com/mattermost/platform/app"
-	"github.com/mattermost/platform/model"
-)
-
-type msgProvider struct {
-}
-
-const (
-	CMD_MSG = "msg"
-)
-
-func init() {
-	RegisterCommandProvider(&msgProvider{})
-}
-
-func (me *msgProvider) GetTrigger() string {
-	return CMD_MSG
-}
-
-func (me *msgProvider) GetCommand(c *Context) *model.Command {
-	return &model.Command{
-		Trigger:          CMD_MSG,
-		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_msg.desc"),
-		AutoCompleteHint: c.T("api.command_msg.hint"),
-		DisplayName:      c.T("api.command_msg.name"),
-	}
-}
-
-func (me *msgProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-
-	splitMessage := strings.SplitN(message, " ", 2)
-
-	parsedMessage := ""
-	targetUsername := ""
-
-	if len(splitMessage) > 1 {
-		parsedMessage = strings.SplitN(message, " ", 2)[1]
-	}
-	targetUsername = strings.SplitN(message, " ", 2)[0]
-	targetUsername = strings.TrimPrefix(targetUsername, "@")
-
-	var userProfile *model.User
-	if result := <-app.Srv.Store.User().GetByUsername(targetUsername); result.Err != nil {
-		l4g.Error(result.Err.Error())
-		return &model.CommandResponse{Text: c.T("api.command_msg.missing.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	} else {
-		userProfile = result.Data.(*model.User)
-	}
-
-	if userProfile.Id == c.Session.UserId {
-		return &model.CommandResponse{Text: c.T("api.command_msg.missing.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-	}
-
-	// Find the channel based on this user
-	channelName := model.GetDMNameFromIds(c.Session.UserId, userProfile.Id)
-
-	targetChannelId := ""
-	if channel := <-app.Srv.Store.Channel().GetByName(c.TeamId, channelName, true); channel.Err != nil {
-		if channel.Err.Id == "store.sql_channel.get_by_name.missing.app_error" {
-			if directChannel, err := app.CreateDirectChannel(c.Session.UserId, userProfile.Id); err != nil {
-				l4g.Error(err.Error())
-				return &model.CommandResponse{Text: c.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-			} else {
-				targetChannelId = directChannel.Id
-			}
-		} else {
-			l4g.Error(channel.Err.Error())
-			return &model.CommandResponse{Text: c.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-		}
-	} else {
-		targetChannelId = channel.Data.(*model.Channel).Id
-	}
-
-	if len(parsedMessage) > 0 {
-		post := &model.Post{}
-		post.Message = parsedMessage
-		post.ChannelId = targetChannelId
-		post.UserId = c.Session.UserId
-		if _, err := app.CreatePost(post, c.TeamId, true); err != nil {
-			return &model.CommandResponse{Text: c.T("api.command_msg.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-		}
-	}
-
-	return &model.CommandResponse{GotoLocation: c.GetTeamURL() + "/channels/" + channelName, Text: "", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
-}
diff --git a/api/auto_channels.go b/app/auto_channels.go
index 1d0f0e7d9..3945a5a4f 100644
--- a/api/auto_channels.go
+++ b/app/auto_channels.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
diff --git a/api/auto_constants.go b/app/auto_constants.go
index a10ae99f2..c8c903e32 100644
--- a/api/auto_constants.go
+++ b/app/auto_constants.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
diff --git a/api/auto_environment.go b/app/auto_environment.go
index 6c7bc2d0a..b0a4f54b8 100644
--- a/api/auto_environment.go
+++ b/app/auto_environment.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
diff --git a/api/auto_posts.go b/app/auto_posts.go
index bb20aadae..b32407539 100644
--- a/api/auto_posts.go
+++ b/app/auto_posts.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"bytes"
diff --git a/api/auto_teams.go b/app/auto_teams.go
index b2e1ace85..6e66f4446 100644
--- a/api/auto_teams.go
+++ b/app/auto_teams.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
diff --git a/api/auto_users.go b/app/auto_users.go
index d8cd8d3a3..7a99cc90b 100644
--- a/api/auto_users.go
+++ b/app/auto_users.go
@@ -1,10 +1,9 @@
 // Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
 	"github.com/mattermost/platform/store"
 	"github.com/mattermost/platform/utils"
@@ -50,8 +49,8 @@ func CreateBasicUser(client *model.Client) *model.AppError {
 			return err
 		}
 		ruser := result.Data.(*model.User)
-		store.Must(app.Srv.Store.User().VerifyEmail(ruser.Id))
-		store.Must(app.Srv.Store.Team().SaveMember(&model.TeamMember{TeamId: basicteam.Id, UserId: ruser.Id}))
+		store.Must(Srv.Store.User().VerifyEmail(ruser.Id))
+		store.Must(Srv.Store.Team().SaveMember(&model.TeamMember{TeamId: basicteam.Id, UserId: ruser.Id}))
 	}
 	return nil
 }
@@ -82,14 +81,14 @@ func (cfg *AutoUserCreator) createRandomUser() (*model.User, bool) {
 	ruser := result.Data.(*model.User)
 
 	status := &model.Status{UserId: ruser.Id, Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: model.GetMillis(), ActiveChannel: ""}
-	if result := <-app.Srv.Store.Status().SaveOrUpdate(status); result.Err != nil {
+	if result := <-Srv.Store.Status().SaveOrUpdate(status); result.Err != nil {
 		result.Err.Translate(utils.T)
 		l4g.Error(result.Err.Error())
 		return nil, false
 	}
 
 	// We need to cheat to verify the user's email
-	store.Must(app.Srv.Store.User().VerifyEmail(ruser.Id))
+	store.Must(Srv.Store.User().VerifyEmail(ruser.Id))
 
 	return result.Data.(*model.User), true
 }
diff --git a/app/command.go b/app/command.go
index 2d5861206..491813efe 100644
--- a/app/command.go
+++ b/app/command.go
@@ -4,9 +4,40 @@
 package app
 
 import (
+	"crypto/tls"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+
+	l4g "github.com/alecthomas/log4go"
 	"github.com/mattermost/platform/model"
+	"github.com/mattermost/platform/utils"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
+type CommandProvider interface {
+	GetTrigger() string
+	GetCommand(T goi18n.TranslateFunc) *model.Command
+	DoCommand(args *model.CommandArgs, message string) *model.CommandResponse
+}
+
+var commandProviders = make(map[string]CommandProvider)
+
+func RegisterCommandProvider(newProvider CommandProvider) {
+	commandProviders[newProvider.GetTrigger()] = newProvider
+}
+
+func GetCommandProvider(name string) CommandProvider {
+	provider, ok := commandProviders[name]
+	if ok {
+		return provider
+	}
+
+	return nil
+}
+
 func CreateCommandPost(post *model.Post, teamId string, response *model.CommandResponse) (*model.Post, *model.AppError) {
 	post.Message = parseSlackLinksToMarkdown(response.Text)
 	post.CreateAt = model.GetMillis()
@@ -29,3 +60,276 @@ func CreateCommandPost(post *model.Post, teamId string, response *model.CommandR
 
 	return post, nil
 }
+
+func ListCommands(teamId string, T goi18n.TranslateFunc) ([]*model.Command, *model.AppError) {
+	commands := make([]*model.Command, 0, 32)
+	seen := make(map[string]bool)
+	for _, value := range commandProviders {
+		cpy := *value.GetCommand(T)
+		if cpy.AutoComplete && !seen[cpy.Id] {
+			cpy.Sanitize()
+			seen[cpy.Trigger] = true
+			commands = append(commands, &cpy)
+		}
+	}
+
+	if *utils.Cfg.ServiceSettings.EnableCommands {
+		if result := <-Srv.Store.Command().GetByTeam(teamId); result.Err != nil {
+			return nil, result.Err
+		} else {
+			teamCmds := result.Data.([]*model.Command)
+			for _, cmd := range teamCmds {
+				if cmd.AutoComplete && !seen[cmd.Id] {
+					cmd.Sanitize()
+					seen[cmd.Trigger] = true
+					commands = append(commands, cmd)
+				}
+			}
+		}
+	}
+
+	return commands, nil
+}
+
+func ListTeamCommands(teamId string) ([]*model.Command, *model.AppError) {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return nil, model.NewAppError("ListTeamCommands", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	if result := <-Srv.Store.Command().GetByTeam(teamId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.Command), nil
+	}
+}
+
+func ExecuteCommand(args *model.CommandArgs) (*model.CommandResponse, *model.AppError) {
+	parts := strings.Split(args.Command, " ")
+	trigger := parts[0][1:]
+	trigger = strings.ToLower(trigger)
+	message := strings.Join(parts[1:], " ")
+	provider := GetCommandProvider(trigger)
+
+	if provider != nil {
+		response := provider.DoCommand(args, message)
+		return HandleCommandResponse(provider.GetCommand(args.T), args, response, true)
+	} else {
+		if !*utils.Cfg.ServiceSettings.EnableCommands {
+			return nil, model.NewAppError("ExecuteCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+		}
+
+		chanChan := Srv.Store.Channel().Get(args.ChannelId, true)
+		teamChan := Srv.Store.Team().Get(args.TeamId)
+		userChan := Srv.Store.User().Get(args.UserId)
+
+		if result := <-Srv.Store.Command().GetByTeam(args.TeamId); result.Err != nil {
+			return nil, result.Err
+		} else {
+
+			var team *model.Team
+			if tr := <-teamChan; tr.Err != nil {
+				return nil, tr.Err
+			} else {
+				team = tr.Data.(*model.Team)
+			}
+
+			var user *model.User
+			if ur := <-userChan; ur.Err != nil {
+				return nil, ur.Err
+			} else {
+				user = ur.Data.(*model.User)
+			}
+
+			var channel *model.Channel
+			if cr := <-chanChan; cr.Err != nil {
+				return nil, cr.Err
+			} else {
+				channel = cr.Data.(*model.Channel)
+			}
+
+			teamCmds := result.Data.([]*model.Command)
+			for _, cmd := range teamCmds {
+				if trigger == cmd.Trigger {
+					l4g.Debug(fmt.Sprintf(utils.T("api.command.execute_command.debug"), trigger, args.UserId))
+
+					p := url.Values{}
+					p.Set("token", cmd.Token)
+
+					p.Set("team_id", cmd.TeamId)
+					p.Set("team_domain", team.Name)
+
+					p.Set("channel_id", args.ChannelId)
+					p.Set("channel_name", channel.Name)
+
+					p.Set("user_id", args.UserId)
+					p.Set("user_name", user.Username)
+
+					p.Set("command", "/"+trigger)
+					p.Set("text", message)
+					p.Set("response_url", "not supported yet")
+
+					method := "POST"
+					if cmd.Method == model.COMMAND_METHOD_GET {
+						method = "GET"
+					}
+
+					tr := &http.Transport{
+						TLSClientConfig: &tls.Config{InsecureSkipVerify: *utils.Cfg.ServiceSettings.EnableInsecureOutgoingConnections},
+					}
+					client := &http.Client{Transport: tr}
+
+					req, _ := http.NewRequest(method, cmd.URL, strings.NewReader(p.Encode()))
+					req.Header.Set("Accept", "application/json")
+					if cmd.Method == model.COMMAND_METHOD_POST {
+						req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+					}
+
+					if resp, err := client.Do(req); err != nil {
+						return nil, model.NewAppError("command", "api.command.execute_command.failed.app_error", map[string]interface{}{"Trigger": trigger}, err.Error(), http.StatusInternalServerError)
+					} else {
+						if resp.StatusCode == http.StatusOK {
+							response := model.CommandResponseFromJson(resp.Body)
+							if response == nil {
+								return nil, model.NewAppError("command", "api.command.execute_command.failed_empty.app_error", map[string]interface{}{"Trigger": trigger}, "", http.StatusInternalServerError)
+							} else {
+								return HandleCommandResponse(cmd, args, response, false)
+							}
+						} else {
+							defer resp.Body.Close()
+							body, _ := ioutil.ReadAll(resp.Body)
+							return nil, model.NewAppError("command", "api.command.execute_command.failed_resp.app_error", map[string]interface{}{"Trigger": trigger, "Status": resp.Status}, string(body), http.StatusInternalServerError)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return nil, model.NewAppError("command", "api.command.execute_command.not_found.app_error", map[string]interface{}{"Trigger": trigger}, "", http.StatusNotFound)
+}
+
+func HandleCommandResponse(command *model.Command, args *model.CommandArgs, response *model.CommandResponse, builtIn bool) (*model.CommandResponse, *model.AppError) {
+	post := &model.Post{}
+	post.ChannelId = args.ChannelId
+	post.RootId = args.RootId
+	post.ParentId = args.ParentId
+	post.UserId = args.UserId
+
+	if !builtIn {
+		post.AddProp("from_webhook", "true")
+	}
+
+	if utils.Cfg.ServiceSettings.EnablePostUsernameOverride {
+		if len(command.Username) != 0 {
+			post.AddProp("override_username", command.Username)
+		} else if len(response.Username) != 0 {
+			post.AddProp("override_username", response.Username)
+		}
+	}
+
+	if utils.Cfg.ServiceSettings.EnablePostIconOverride {
+		if len(command.IconURL) != 0 {
+			post.AddProp("override_icon_url", command.IconURL)
+		} else if len(response.IconURL) != 0 {
+			post.AddProp("override_icon_url", response.IconURL)
+		} else {
+			post.AddProp("override_icon_url", "")
+		}
+	}
+
+	if _, err := CreateCommandPost(post, args.TeamId, response); err != nil {
+		l4g.Error(err.Error())
+	}
+
+	return response, nil
+}
+
+func CreateCommand(cmd *model.Command) (*model.Command, *model.AppError) {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return nil, model.NewAppError("CreateCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	cmd.Trigger = strings.ToLower(cmd.Trigger)
+
+	if result := <-Srv.Store.Command().GetByTeam(cmd.TeamId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		teamCmds := result.Data.([]*model.Command)
+		for _, existingCommand := range teamCmds {
+			if cmd.Trigger == existingCommand.Trigger {
+				return nil, model.NewAppError("CreateCommand", "api.command.duplicate_trigger.app_error", nil, "", http.StatusBadRequest)
+			}
+		}
+		for _, builtInProvider := range commandProviders {
+			builtInCommand := *builtInProvider.GetCommand(utils.T)
+			if cmd.Trigger == builtInCommand.Trigger {
+				return nil, model.NewAppError("CreateCommand", "api.command.duplicate_trigger.app_error", nil, "", http.StatusBadRequest)
+			}
+		}
+	}
+
+	if result := <-Srv.Store.Command().Save(cmd); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Command), nil
+	}
+}
+
+func GetCommand(commandId string) (*model.Command, *model.AppError) {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return nil, model.NewAppError("GetCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	if result := <-Srv.Store.Command().Get(commandId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Command), nil
+	}
+}
+
+func UpdateCommand(oldCmd, updatedCmd *model.Command) (*model.Command, *model.AppError) {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return nil, model.NewAppError("UpdateCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	updatedCmd.Trigger = strings.ToLower(updatedCmd.Trigger)
+	updatedCmd.Id = oldCmd.Id
+	updatedCmd.Token = oldCmd.Token
+	updatedCmd.CreateAt = oldCmd.CreateAt
+	updatedCmd.UpdateAt = model.GetMillis()
+	updatedCmd.DeleteAt = oldCmd.DeleteAt
+	updatedCmd.CreatorId = oldCmd.CreatorId
+	updatedCmd.TeamId = oldCmd.TeamId
+
+	if result := <-Srv.Store.Command().Update(updatedCmd); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Command), nil
+	}
+}
+
+func RegenCommandToken(cmd *model.Command) (*model.Command, *model.AppError) {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return nil, model.NewAppError("RegenCommandToken", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	cmd.Token = model.NewId()
+
+	if result := <-Srv.Store.Command().Update(cmd); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Command), nil
+	}
+}
+
+func DeleteCommand(commandId string) *model.AppError {
+	if !*utils.Cfg.ServiceSettings.EnableCommands {
+		return model.NewAppError("DeleteCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
+	}
+
+	if err := (<-Srv.Store.Command().Delete(commandId, model.GetMillis())).Err; err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/api/command_away.go b/app/command_away.go
index 6a488c081..55553fa3f 100644
--- a/api/command_away.go
+++ b/app/command_away.go
@@ -1,11 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type AwayProvider struct {
@@ -23,21 +23,21 @@ func (me *AwayProvider) GetTrigger() string {
 	return CMD_AWAY
 }
 
-func (me *AwayProvider) GetCommand(c *Context) *model.Command {
+func (me *AwayProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_AWAY,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_away.desc"),
-		DisplayName:      c.T("api.command_away.name"),
+		AutoCompleteDesc: T("api.command_away.desc"),
+		DisplayName:      T("api.command_away.name"),
 	}
 }
 
-func (me *AwayProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	rmsg := c.T("api.command_away.success")
+func (me *AwayProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	rmsg := args.T("api.command_away.success")
 	if len(message) > 0 {
 		rmsg = message + " " + rmsg
 	}
-	app.SetStatusAwayIfNeeded(c.Session.UserId, true)
+	SetStatusAwayIfNeeded(args.UserId, true)
 
 	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: rmsg}
 }
diff --git a/api/command_echo.go b/app/command_echo.go
index 2e931e414..40d70e54a 100644
--- a/api/command_echo.go
+++ b/app/command_echo.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"strconv"
@@ -9,8 +9,8 @@ import (
 	"time"
 
 	l4g "github.com/alecthomas/log4go"
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 var echoSem chan bool
@@ -30,19 +30,19 @@ func (me *EchoProvider) GetTrigger() string {
 	return CMD_ECHO
 }
 
-func (me *EchoProvider) GetCommand(c *Context) *model.Command {
+func (me *EchoProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_ECHO,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_echo.desc"),
-		AutoCompleteHint: c.T("api.command_echo.hint"),
-		DisplayName:      c.T("api.command_echo.name"),
+		AutoCompleteDesc: T("api.command_echo.desc"),
+		AutoCompleteHint: T("api.command_echo.hint"),
+		DisplayName:      T("api.command_echo.name"),
 	}
 }
 
-func (me *EchoProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *EchoProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	if len(message) == 0 {
-		return &model.CommandResponse{Text: c.T("api.command_echo.message.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: args.T("api.command_echo.message.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
 
 	maxThreads := 100
@@ -64,7 +64,7 @@ func (me *EchoProvider) DoCommand(c *Context, args *model.CommandArgs, message s
 	}
 
 	if delay > 10000 {
-		return &model.CommandResponse{Text: c.T("api.command_echo.delay.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: args.T("api.command_echo.delay.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
 
 	if echoSem == nil {
@@ -73,7 +73,7 @@ func (me *EchoProvider) DoCommand(c *Context, args *model.CommandArgs, message s
 	}
 
 	if len(echoSem) >= maxThreads {
-		return &model.CommandResponse{Text: c.T("api.command_echo.high_volume.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: args.T("api.command_echo.high_volume.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
 
 	echoSem <- true
@@ -84,12 +84,12 @@ func (me *EchoProvider) DoCommand(c *Context, args *model.CommandArgs, message s
 		post.RootId = args.RootId
 		post.ParentId = args.ParentId
 		post.Message = message
-		post.UserId = c.Session.UserId
+		post.UserId = args.UserId
 
 		time.Sleep(time.Duration(delay) * time.Second)
 
-		if _, err := app.CreatePost(post, c.TeamId, true); err != nil {
-			l4g.Error(c.T("api.command_echo.create.app_error"), err)
+		if _, err := CreatePost(post, args.TeamId, true); err != nil {
+			l4g.Error(args.T("api.command_echo.create.app_error"), err)
 		}
 	}()
 
diff --git a/app/command_expand_collapse.go b/app/command_expand_collapse.go
new file mode 100644
index 000000000..a4a152c60
--- /dev/null
+++ b/app/command_expand_collapse.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package app
+
+import (
+	"strconv"
+
+	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
+)
+
+type ExpandProvider struct {
+}
+
+type CollapseProvider struct {
+}
+
+const (
+	CMD_EXPAND   = "expand"
+	CMD_COLLAPSE = "collapse"
+)
+
+func init() {
+	RegisterCommandProvider(&ExpandProvider{})
+	RegisterCommandProvider(&CollapseProvider{})
+}
+
+func (me *ExpandProvider) GetTrigger() string {
+	return CMD_EXPAND
+}
+
+func (me *CollapseProvider) GetTrigger() string {
+	return CMD_COLLAPSE
+}
+
+func (me *ExpandProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
+	return &model.Command{
+		Trigger:          CMD_EXPAND,
+		AutoComplete:     true,
+		AutoCompleteDesc: T("api.command_expand.desc"),
+		DisplayName:      T("api.command_expand.name"),
+	}
+}
+
+func (me *CollapseProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
+	return &model.Command{
+		Trigger:          CMD_COLLAPSE,
+		AutoComplete:     true,
+		AutoCompleteDesc: T("api.command_collapse.desc"),
+		DisplayName:      T("api.command_collapse.name"),
+	}
+}
+
+func (me *ExpandProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	return setCollapsePreference(args, false)
+}
+
+func (me *CollapseProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	return setCollapsePreference(args, true)
+}
+
+func setCollapsePreference(args *model.CommandArgs, isCollapse bool) *model.CommandResponse {
+	pref := model.Preference{
+		UserId:   args.UserId,
+		Category: model.PREFERENCE_CATEGORY_DISPLAY_SETTINGS,
+		Name:     model.PREFERENCE_NAME_COLLAPSE_SETTING,
+		Value:    strconv.FormatBool(isCollapse),
+	}
+
+	if result := <-Srv.Store.Preference().Save(&model.Preferences{pref}); result.Err != nil {
+		return &model.CommandResponse{Text: args.T("api.command_expand_collapse.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	}
+
+	socketMessage := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_PREFERENCE_CHANGED, "", "", args.UserId, nil)
+	socketMessage.Add("preference", pref.ToJson())
+	go Publish(socketMessage)
+
+	var rmsg string
+
+	if isCollapse {
+		rmsg = args.T("api.command_collapse.success")
+	} else {
+		rmsg = args.T("api.command_expand.success")
+	}
+	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: rmsg}
+}
diff --git a/api/command_invite_people.go b/app/command_invite_people.go
index b8f1827b0..12ef03f45 100644
--- a/api/command_invite_people.go
+++ b/app/command_invite_people.go
@@ -1,15 +1,15 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"strings"
 
 	l4g "github.com/alecthomas/log4go"
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
 	"github.com/mattermost/platform/utils"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type InvitePeopleProvider struct {
@@ -27,19 +27,19 @@ func (me *InvitePeopleProvider) GetTrigger() string {
 	return CMD_INVITE_PEOPLE
 }
 
-func (me *InvitePeopleProvider) GetCommand(c *Context) *model.Command {
+func (me *InvitePeopleProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_INVITE_PEOPLE,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command.invite_people.desc"),
-		AutoCompleteHint: c.T("api.command.invite_people.hint"),
-		DisplayName:      c.T("api.command.invite_people.name"),
+		AutoCompleteDesc: T("api.command.invite_people.desc"),
+		AutoCompleteHint: T("api.command.invite_people.hint"),
+		DisplayName:      T("api.command.invite_people.name"),
 	}
 }
 
-func (me *InvitePeopleProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *InvitePeopleProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	if !utils.Cfg.EmailSettings.SendEmailNotifications {
-		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command.invite_people.email_off")}
+		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command.invite_people.email_off")}
 	}
 
 	emailList := strings.Fields(message)
@@ -52,13 +52,13 @@ func (me *InvitePeopleProvider) DoCommand(c *Context, args *model.CommandArgs, m
 	}
 
 	if len(emailList) == 0 {
-		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command.invite_people.no_email")}
+		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command.invite_people.no_email")}
 	}
 
-	if err := app.InviteNewUsersToTeam(emailList, c.TeamId, c.Session.UserId, c.GetSiteURL()); err != nil {
+	if err := InviteNewUsersToTeam(emailList, args.TeamId, args.UserId, args.SiteURL); err != nil {
 		l4g.Error(err.Error())
-		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command.invite_people.fail")}
+		return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command.invite_people.fail")}
 	}
 
-	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command.invite_people.sent")}
+	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command.invite_people.sent")}
 }
diff --git a/app/command_join.go b/app/command_join.go
new file mode 100644
index 000000000..5b19dd7a0
--- /dev/null
+++ b/app/command_join.go
@@ -0,0 +1,62 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package app
+
+import (
+	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
+)
+
+type JoinProvider struct {
+}
+
+const (
+	CMD_JOIN = "join"
+)
+
+func init() {
+	RegisterCommandProvider(&JoinProvider{})
+}
+
+func (me *JoinProvider) GetTrigger() string {
+	return CMD_JOIN
+}
+
+func (me *JoinProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
+	return &model.Command{
+		Trigger:          CMD_JOIN,
+		AutoComplete:     true,
+		AutoCompleteDesc: T("api.command_join.desc"),
+		AutoCompleteHint: T("api.command_join.hint"),
+		DisplayName:      T("api.command_join.name"),
+	}
+}
+
+func (me *JoinProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	if result := <-Srv.Store.Channel().GetByName(args.TeamId, message, true); result.Err != nil {
+		return &model.CommandResponse{Text: args.T("api.command_join.list.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	} else {
+		channel := result.Data.(*model.Channel)
+
+		if channel.Name == message {
+
+			if channel.Type != model.CHANNEL_OPEN {
+				return &model.CommandResponse{Text: args.T("api.command_join.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			}
+
+			if err := JoinChannel(channel, args.UserId); err != nil {
+				return &model.CommandResponse{Text: args.T("api.command_join.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			}
+
+			team, err := GetTeam(channel.TeamId)
+			if err != nil {
+				return &model.CommandResponse{Text: args.T("api.command_join.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			}
+
+			return &model.CommandResponse{GotoLocation: args.SiteURL + "/" + team.Name + "/channels/" + channel.Name, Text: args.T("api.command_join.success"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		}
+	}
+
+	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command_join.missing.app_error")}
+}
diff --git a/api/command_loadtest.go b/app/command_loadtest.go
index dfbbadc3b..d3c7474ae 100644
--- a/api/command_loadtest.go
+++ b/app/command_loadtest.go
@@ -1,7 +1,7 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"io"
@@ -11,9 +11,9 @@ import (
 	"strings"
 
 	l4g "github.com/alecthomas/log4go"
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
 	"github.com/mattermost/platform/utils"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 var usage = `Mattermost load testing commands to help configure the system
@@ -75,7 +75,7 @@ func (me *LoadTestProvider) GetTrigger() string {
 	return CMD_LOADTEST
 }
 
-func (me *LoadTestProvider) GetCommand(c *Context) *model.Command {
+func (me *LoadTestProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_LOADTEST,
 		AutoComplete:     false,
@@ -85,44 +85,42 @@ func (me *LoadTestProvider) GetCommand(c *Context) *model.Command {
 	}
 }
 
-func (me *LoadTestProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	channelId := args.ChannelId
-
+func (me *LoadTestProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	//This command is only available when EnableTesting is true
 	if !utils.Cfg.ServiceSettings.EnableTesting {
 		return &model.CommandResponse{}
 	}
 
 	if strings.HasPrefix(message, "setup") {
-		return me.SetupCommand(c, channelId, message)
+		return me.SetupCommand(args, message)
 	}
 
 	if strings.HasPrefix(message, "users") {
-		return me.UsersCommand(c, channelId, message)
+		return me.UsersCommand(args, message)
 	}
 
 	if strings.HasPrefix(message, "channels") {
-		return me.ChannelsCommand(c, channelId, message)
+		return me.ChannelsCommand(args, message)
 	}
 
 	if strings.HasPrefix(message, "posts") {
-		return me.PostsCommand(c, channelId, message)
+		return me.PostsCommand(args, message)
 	}
 
 	if strings.HasPrefix(message, "url") {
-		return me.UrlCommand(c, channelId, message)
+		return me.UrlCommand(args, message)
 	}
 	if strings.HasPrefix(message, "json") {
-		return me.JsonCommand(c, channelId, message)
+		return me.JsonCommand(args, message)
 	}
-	return me.HelpCommand(c, channelId, message)
+	return me.HelpCommand(args, message)
 }
 
-func (me *LoadTestProvider) HelpCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) HelpCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	return &model.CommandResponse{Text: usage, ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) SetupCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) SetupCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	tokens := strings.Fields(strings.TrimPrefix(message, "setup"))
 	doTeams := contains(tokens, "teams")
 	doFuzz := contains(tokens, "fuzz")
@@ -160,7 +158,7 @@ func (me *LoadTestProvider) SetupCommand(c *Context, channelId string, message s
 			numPosts, _ = strconv.Atoi(tokens[numArgs+2])
 		}
 	}
-	client := model.NewClient(c.GetSiteURL())
+	client := model.NewClient(args.SiteURL)
 
 	if doTeams {
 		if err := CreateBasicUser(client); err != nil {
@@ -186,14 +184,14 @@ func (me *LoadTestProvider) SetupCommand(c *Context, channelId string, message s
 	} else {
 
 		var team *model.Team
-		if tr := <-app.Srv.Store.Team().Get(c.TeamId); tr.Err != nil {
+		if tr := <-Srv.Store.Team().Get(args.TeamId); tr.Err != nil {
 			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 		} else {
 			team = tr.Data.(*model.Team)
 		}
 
-		client.MockSession(c.Session.Token)
-		client.SetTeamId(c.TeamId)
+		client.MockSession(args.Session.Token)
+		client.SetTeamId(args.TeamId)
 		CreateTestEnvironmentInTeam(
 			client,
 			team,
@@ -206,7 +204,7 @@ func (me *LoadTestProvider) SetupCommand(c *Context, channelId string, message s
 	return &model.CommandResponse{Text: "Created enviroment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) UsersCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) UsersCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "users"))
 
 	doFuzz := false
@@ -221,13 +219,13 @@ func (me *LoadTestProvider) UsersCommand(c *Context, channelId string, message s
 	}
 
 	var team *model.Team
-	if tr := <-app.Srv.Store.Team().Get(c.TeamId); tr.Err != nil {
+	if tr := <-Srv.Store.Team().Get(args.TeamId); tr.Err != nil {
 		return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	} else {
 		team = tr.Data.(*model.Team)
 	}
 
-	client := model.NewClient(c.GetSiteURL())
+	client := model.NewClient(args.SiteURL)
 	client.SetTeamId(team.Id)
 	userCreator := NewAutoUserCreator(client, team)
 	userCreator.Fuzzy = doFuzz
@@ -236,7 +234,7 @@ func (me *LoadTestProvider) UsersCommand(c *Context, channelId string, message s
 	return &model.CommandResponse{Text: "Added users", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) ChannelsCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) ChannelsCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "channels"))
 
 	doFuzz := false
@@ -251,15 +249,15 @@ func (me *LoadTestProvider) ChannelsCommand(c *Context, channelId string, messag
 	}
 
 	var team *model.Team
-	if tr := <-app.Srv.Store.Team().Get(c.TeamId); tr.Err != nil {
+	if tr := <-Srv.Store.Team().Get(args.TeamId); tr.Err != nil {
 		return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	} else {
 		team = tr.Data.(*model.Team)
 	}
 
-	client := model.NewClient(c.GetSiteURL())
+	client := model.NewClient(args.SiteURL)
 	client.SetTeamId(team.Id)
-	client.MockSession(c.Session.Token)
+	client.MockSession(args.Session.Token)
 	channelCreator := NewAutoChannelCreator(client, team)
 	channelCreator.Fuzzy = doFuzz
 	channelCreator.CreateTestChannels(channelsr)
@@ -267,7 +265,7 @@ func (me *LoadTestProvider) ChannelsCommand(c *Context, channelId string, messag
 	return &model.CommandResponse{Text: "Added channels", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) PostsCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) PostsCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "posts"))
 
 	doFuzz := false
@@ -290,7 +288,7 @@ func (me *LoadTestProvider) PostsCommand(c *Context, channelId string, message s
 	}
 
 	var usernames []string
-	if result := <-app.Srv.Store.User().GetProfiles(c.TeamId, 0, 1000); result.Err == nil {
+	if result := <-Srv.Store.User().GetProfiles(args.TeamId, 0, 1000); result.Err == nil {
 		profileUsers := result.Data.([]*model.User)
 		usernames = make([]string, len(profileUsers))
 		i := 0
@@ -300,10 +298,10 @@ func (me *LoadTestProvider) PostsCommand(c *Context, channelId string, message s
 		}
 	}
 
-	client := model.NewClient(c.GetSiteURL())
-	client.SetTeamId(c.TeamId)
-	client.MockSession(c.Session.Token)
-	testPoster := NewAutoPostCreator(client, channelId)
+	client := model.NewClient(args.SiteURL)
+	client.SetTeamId(args.TeamId)
+	client.MockSession(args.Session.Token)
+	testPoster := NewAutoPostCreator(client, args.ChannelId)
 	testPoster.Fuzzy = doFuzz
 	testPoster.Users = usernames
 
@@ -317,7 +315,7 @@ func (me *LoadTestProvider) PostsCommand(c *Context, channelId string, message s
 	return &model.CommandResponse{Text: "Added posts", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) UrlCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) UrlCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	url := strings.TrimSpace(strings.TrimPrefix(message, "url"))
 	if len(url) == 0 {
 		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
@@ -356,10 +354,10 @@ func (me *LoadTestProvider) UrlCommand(c *Context, channelId string, message str
 
 		post := &model.Post{}
 		post.Message = string(bytes[:length])
-		post.ChannelId = channelId
-		post.UserId = c.Session.UserId
+		post.ChannelId = args.ChannelId
+		post.UserId = args.UserId
 
-		if _, err := app.CreatePost(post, c.TeamId, false); err != nil {
+		if _, err := CreatePost(post, args.TeamId, false); err != nil {
 			return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 		}
 	}
@@ -367,7 +365,7 @@ func (me *LoadTestProvider) UrlCommand(c *Context, channelId string, message str
 	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) JsonCommand(c *Context, channelId string, message string) *model.CommandResponse {
+func (me *LoadTestProvider) JsonCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	url := strings.TrimSpace(strings.TrimPrefix(message, "json"))
 	if len(url) == 0 {
 		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
@@ -392,13 +390,13 @@ func (me *LoadTestProvider) JsonCommand(c *Context, channelId string, message st
 	}
 
 	post := model.PostFromJson(contents)
-	post.ChannelId = channelId
-	post.UserId = c.Session.UserId
+	post.ChannelId = args.ChannelId
+	post.UserId = args.UserId
 	if post.Message == "" {
 		post.Message = message
 	}
 
-	if _, err := app.CreatePost(post, c.TeamId, false); err != nil {
+	if _, err := CreatePost(post, args.TeamId, false); err != nil {
 		return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 	}
 	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
diff --git a/api/command_logout.go b/app/command_logout.go
index 0eaa9a0ba..1a353056e 100644
--- a/api/command_logout.go
+++ b/app/command_logout.go
@@ -1,11 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type LogoutProvider struct {
@@ -23,23 +23,23 @@ func (me *LogoutProvider) GetTrigger() string {
 	return CMD_LOGOUT
 }
 
-func (me *LogoutProvider) GetCommand(c *Context) *model.Command {
+func (me *LogoutProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_LOGOUT,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_logout.desc"),
+		AutoCompleteDesc: T("api.command_logout.desc"),
 		AutoCompleteHint: "",
-		DisplayName:      c.T("api.command_logout.name"),
+		DisplayName:      T("api.command_logout.name"),
 	}
 }
 
-func (me *LogoutProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	FAIL := &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: c.T("api.command_logout.fail_message")}
+func (me *LogoutProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	FAIL := &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: args.T("api.command_logout.fail_message")}
 	SUCCESS := &model.CommandResponse{GotoLocation: "/login"}
 
 	// We can't actually remove the user's cookie from here so we just dump their session and let the browser figure it out
-	if c.Session.Id != "" {
-		if err := app.RevokeSessionById(c.Session.Id); err != nil {
+	if args.Session.Id != "" {
+		if err := RevokeSessionById(args.Session.Id); err != nil {
 			return FAIL
 		}
 		return SUCCESS
diff --git a/api/command_me.go b/app/command_me.go
index a3cda472a..bb29ec1e0 100644
--- a/api/command_me.go
+++ b/app/command_me.go
@@ -1,10 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type MeProvider struct {
@@ -22,16 +23,16 @@ func (me *MeProvider) GetTrigger() string {
 	return CMD_ME
 }
 
-func (me *MeProvider) GetCommand(c *Context) *model.Command {
+func (me *MeProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_ME,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_me.desc"),
-		AutoCompleteHint: c.T("api.command_me.hint"),
-		DisplayName:      c.T("api.command_me.name"),
+		AutoCompleteDesc: T("api.command_me.desc"),
+		AutoCompleteHint: T("api.command_me.hint"),
+		DisplayName:      T("api.command_me.name"),
 	}
 }
 
-func (me *MeProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *MeProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_IN_CHANNEL, Text: "*" + message + "*"}
 }
diff --git a/app/command_msg.go b/app/command_msg.go
new file mode 100644
index 000000000..fd4ace61a
--- /dev/null
+++ b/app/command_msg.go
@@ -0,0 +1,110 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package app
+
+import (
+	"strings"
+
+	l4g "github.com/alecthomas/log4go"
+	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
+)
+
+type msgProvider struct {
+}
+
+const (
+	CMD_MSG = "msg"
+)
+
+func init() {
+	RegisterCommandProvider(&msgProvider{})
+}
+
+func (me *msgProvider) GetTrigger() string {
+	return CMD_MSG
+}
+
+func (me *msgProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
+	return &model.Command{
+		Trigger:          CMD_MSG,
+		AutoComplete:     true,
+		AutoCompleteDesc: T("api.command_msg.desc"),
+		AutoCompleteHint: T("api.command_msg.hint"),
+		DisplayName:      T("api.command_msg.name"),
+	}
+}
+
+func (me *msgProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+
+	splitMessage := strings.SplitN(message, " ", 2)
+
+	parsedMessage := ""
+	targetUsername := ""
+	teamId := ""
+
+	if len(splitMessage) > 1 {
+		parsedMessage = strings.SplitN(message, " ", 2)[1]
+	}
+	targetUsername = strings.SplitN(message, " ", 2)[0]
+	targetUsername = strings.TrimPrefix(targetUsername, "@")
+
+	var userProfile *model.User
+	if result := <-Srv.Store.User().GetByUsername(targetUsername); result.Err != nil {
+		l4g.Error(result.Err.Error())
+		return &model.CommandResponse{Text: args.T("api.command_msg.missing.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	} else {
+		userProfile = result.Data.(*model.User)
+	}
+
+	if userProfile.Id == args.UserId {
+		return &model.CommandResponse{Text: args.T("api.command_msg.missing.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	}
+
+	// Find the channel based on this user
+	channelName := model.GetDMNameFromIds(args.UserId, userProfile.Id)
+
+	targetChannelId := ""
+	if channel := <-Srv.Store.Channel().GetByName(args.TeamId, channelName, true); channel.Err != nil {
+		if channel.Err.Id == "store.sql_channel.get_by_name.missing.app_error" {
+			if directChannel, err := CreateDirectChannel(args.UserId, userProfile.Id); err != nil {
+				l4g.Error(err.Error())
+				return &model.CommandResponse{Text: args.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			} else {
+				targetChannelId = directChannel.Id
+			}
+		} else {
+			l4g.Error(channel.Err.Error())
+			return &model.CommandResponse{Text: args.T("api.command_msg.dm_fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		}
+	} else {
+		channel := channel.Data.(*model.Channel)
+		targetChannelId = channel.Id
+		teamId = channel.TeamId
+	}
+
+	if len(parsedMessage) > 0 {
+		post := &model.Post{}
+		post.Message = parsedMessage
+		post.ChannelId = targetChannelId
+		post.UserId = args.UserId
+		if _, err := CreatePost(post, args.TeamId, true); err != nil {
+			return &model.CommandResponse{Text: args.T("api.command_msg.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		}
+	}
+
+	if teamId == "" {
+		if len(args.Session.TeamMembers) == 0 {
+			return &model.CommandResponse{Text: args.T("api.command_msg.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		}
+		teamId = args.Session.TeamMembers[0].TeamId
+	}
+
+	team, err := GetTeam(teamId)
+	if err != nil {
+		return &model.CommandResponse{Text: args.T("api.command_msg.fail.app_error"), ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	}
+
+	return &model.CommandResponse{GotoLocation: args.SiteURL + "/" + team.Name + "/channels/" + channelName, Text: "", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+}
diff --git a/api/command_offline.go b/app/command_offline.go
index a4bcdf8a5..6e2c125f8 100644
--- a/api/command_offline.go
+++ b/app/command_offline.go
@@ -1,11 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type OfflineProvider struct {
@@ -23,21 +23,21 @@ func (me *OfflineProvider) GetTrigger() string {
 	return CMD_OFFLINE
 }
 
-func (me *OfflineProvider) GetCommand(c *Context) *model.Command {
+func (me *OfflineProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_OFFLINE,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_offline.desc"),
-		DisplayName:      c.T("api.command_offline.name"),
+		AutoCompleteDesc: T("api.command_offline.desc"),
+		DisplayName:      T("api.command_offline.name"),
 	}
 }
 
-func (me *OfflineProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	rmsg := c.T("api.command_offline.success")
+func (me *OfflineProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	rmsg := args.T("api.command_offline.success")
 	if len(message) > 0 {
 		rmsg = message + " " + rmsg
 	}
-	app.SetStatusOffline(c.Session.UserId, true)
+	SetStatusOffline(args.UserId, true)
 
 	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: rmsg}
 }
diff --git a/api/command_online.go b/app/command_online.go
index 81d3e1fd6..bd6fbab60 100644
--- a/api/command_online.go
+++ b/app/command_online.go
@@ -1,11 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
-	"github.com/mattermost/platform/app"
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type OnlineProvider struct {
@@ -23,21 +23,21 @@ func (me *OnlineProvider) GetTrigger() string {
 	return CMD_ONLINE
 }
 
-func (me *OnlineProvider) GetCommand(c *Context) *model.Command {
+func (me *OnlineProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_ONLINE,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_online.desc"),
-		DisplayName:      c.T("api.command_online.name"),
+		AutoCompleteDesc: T("api.command_online.desc"),
+		DisplayName:      T("api.command_online.name"),
 	}
 }
 
-func (me *OnlineProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
-	rmsg := c.T("api.command_online.success")
+func (me *OnlineProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
+	rmsg := args.T("api.command_online.success")
 	if len(message) > 0 {
 		rmsg = message + " " + rmsg
 	}
-	app.SetStatusOnline(c.Session.UserId, c.Session.Id, true)
+	SetStatusOnline(args.UserId, args.Session.Id, true)
 
 	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: rmsg}
 }
diff --git a/api/command_shortcuts.go b/app/command_shortcuts.go
index 1664221c1..93e5f0f51 100644
--- a/api/command_shortcuts.go
+++ b/app/command_shortcuts.go
@@ -1,13 +1,14 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"bytes"
 	"strings"
 
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type ShortcutsProvider struct {
@@ -25,17 +26,17 @@ func (me *ShortcutsProvider) GetTrigger() string {
 	return CMD_SHORTCUTS
 }
 
-func (me *ShortcutsProvider) GetCommand(c *Context) *model.Command {
+func (me *ShortcutsProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_SHORTCUTS,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_shortcuts.desc"),
+		AutoCompleteDesc: T("api.command_shortcuts.desc"),
 		AutoCompleteHint: "",
-		DisplayName:      c.T("api.command_shortcuts.name"),
+		DisplayName:      T("api.command_shortcuts.name"),
 	}
 }
 
-func (me *ShortcutsProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *ShortcutsProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	shortcutIds := [28]string{
 		"api.command_shortcuts.header",
 		// Nav shortcuts
@@ -73,21 +74,21 @@ func (me *ShortcutsProvider) DoCommand(c *Context, args *model.CommandArgs, mess
 	var osDependentWords map[string]interface{}
 	if strings.Contains(message, "mac") {
 		osDependentWords = map[string]interface{}{
-			"CmdOrCtrl":      c.T("api.command_shortcuts.cmd"),
-			"ChannelPrevCmd": c.T("api.command_shortcuts.browser.channel_prev.cmd_mac"),
-			"ChannelNextCmd": c.T("api.command_shortcuts.browser.channel_next.cmd_mac"),
+			"CmdOrCtrl":      args.T("api.command_shortcuts.cmd"),
+			"ChannelPrevCmd": args.T("api.command_shortcuts.browser.channel_prev.cmd_mac"),
+			"ChannelNextCmd": args.T("api.command_shortcuts.browser.channel_next.cmd_mac"),
 		}
 	} else {
 		osDependentWords = map[string]interface{}{
-			"CmdOrCtrl":      c.T("api.command_shortcuts.ctrl"),
-			"ChannelPrevCmd": c.T("api.command_shortcuts.browser.channel_prev.cmd"),
-			"ChannelNextCmd": c.T("api.command_shortcuts.browser.channel_next.cmd"),
+			"CmdOrCtrl":      args.T("api.command_shortcuts.ctrl"),
+			"ChannelPrevCmd": args.T("api.command_shortcuts.browser.channel_prev.cmd"),
+			"ChannelNextCmd": args.T("api.command_shortcuts.browser.channel_next.cmd"),
 		}
 	}
 
 	var buffer bytes.Buffer
 	for _, element := range shortcutIds {
-		buffer.WriteString(c.T(element, osDependentWords))
+		buffer.WriteString(args.T(element, osDependentWords))
 	}
 
 	return &model.CommandResponse{ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL, Text: buffer.String()}
diff --git a/api/command_shrug.go b/app/command_shrug.go
index 899fcab33..12d1039ec 100644
--- a/api/command_shrug.go
+++ b/app/command_shrug.go
@@ -1,10 +1,11 @@
 // Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
 // See License.txt for license information.
 
-package api
+package app
 
 import (
 	"github.com/mattermost/platform/model"
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type ShrugProvider struct {
@@ -22,17 +23,17 @@ func (me *ShrugProvider) GetTrigger() string {
 	return CMD_SHRUG
 }
 
-func (me *ShrugProvider) GetCommand(c *Context) *model.Command {
+func (me *ShrugProvider) GetCommand(T goi18n.TranslateFunc) *model.Command {
 	return &model.Command{
 		Trigger:          CMD_SHRUG,
 		AutoComplete:     true,
-		AutoCompleteDesc: c.T("api.command_shrug.desc"),
-		AutoCompleteHint: c.T("api.command_shrug.hint"),
-		DisplayName:      c.T("api.command_shrug.name"),
+		AutoCompleteDesc: T("api.command_shrug.desc"),
+		AutoCompleteHint: T("api.command_shrug.hint"),
+		DisplayName:      T("api.command_shrug.name"),
 	}
 }
 
-func (me *ShrugProvider) DoCommand(c *Context, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *ShrugProvider) DoCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	rmsg := `¯\\\_(ツ)\_/¯`
 	if len(message) > 0 {
 		rmsg = message + " " + rmsg
diff --git a/manualtesting/manual_testing.go b/manualtesting/manual_testing.go
index 33192ff5e..677b9999d 100644
--- a/manualtesting/manual_testing.go
+++ b/manualtesting/manual_testing.go
@@ -92,7 +92,7 @@ func manualTest(c *api.Context, w http.ResponseWriter, r *http.Request) {
 		user := &model.User{
 			Email:    "success+" + model.NewId() + "simulator.amazonses.com",
 			Nickname: username[0],
-			Password: api.USER_PASSWORD}
+			Password: app.USER_PASSWORD}
 
 		result, err := client.CreateUser(user, "")
 		if err != nil {
@@ -107,7 +107,7 @@ func manualTest(c *api.Context, w http.ResponseWriter, r *http.Request) {
 		userID = newuser.Id
 
 		// Login as user to generate auth token
-		_, err = client.LoginById(newuser.Id, api.USER_PASSWORD)
+		_, err = client.LoginById(newuser.Id, app.USER_PASSWORD)
 		if err != nil {
 			c.Err = err
 			return
diff --git a/model/command_args.go b/model/command_args.go
index 4da5dc760..f512410a3 100644
--- a/model/command_args.go
+++ b/model/command_args.go
@@ -6,13 +6,20 @@ package model
 import (
 	"encoding/json"
 	"io"
+
+	goi18n "github.com/nicksnyder/go-i18n/i18n"
 )
 
 type CommandArgs struct {
-	ChannelId string `json:"channel_id"`
-	RootId    string `json:"root_id"`
-	ParentId  string `json:"parent_id"`
-	Command   string `json:"command"`
+	UserId    string               `json:"user_id"`
+	ChannelId string               `json:"channel_id"`
+	TeamId    string               `json:"team_id"`
+	RootId    string               `json:"root_id"`
+	ParentId  string               `json:"parent_id"`
+	Command   string               `json:"command"`
+	SiteURL   string               `json:"-"`
+	T         goi18n.TranslateFunc `json:"-"`
+	Session   Session              `json:"-"`
 }
 
 func (o *CommandArgs) ToJson() string {