diff --git a/backend/cmd/admin.go b/backend/cmd/admin.go
new file mode 100644
index 0000000..4aac1fd
--- /dev/null
+++ b/backend/cmd/admin.go
@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+	"s-ui/config"
+	"s-ui/database"
+	"s-ui/service"
+)
+
+func resetAdmin() {
+	err := database.InitDB(config.GetDBPath())
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	userService := service.UserService{}
+	err = userService.UpdateFirstUser("admin", "admin")
+	if err != nil {
+		fmt.Println("reset admin credentials failed:", err)
+	} else {
+		fmt.Println("reset admin credentials success")
+	}
+}
+
+func updateAdmin(username string, password string) {
+	err := database.InitDB(config.GetDBPath())
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	if username != "" || password != "" {
+		userService := service.UserService{}
+		err := userService.UpdateFirstUser(username, password)
+		if err != nil {
+			fmt.Println("reset admin credentials failed:", err)
+		} else {
+			fmt.Println("reset admin credentials success")
+		}
+	}
+}
+
+func showAdmin() {
+	userService := service.UserService{}
+	userModel, err := userService.GetFirstUser()
+	if err != nil {
+		fmt.Println("get current user info failed,error info:", err)
+	}
+	username := userModel.Username
+	userpasswd := userModel.Password
+	if (username == "") || (userpasswd == "") {
+		fmt.Println("current username or password is empty")
+	}
+	fmt.Println("First admin credentials:")
+	fmt.Println("\tUsername:\t", username)
+	fmt.Println("\tPassword:\t", userpasswd)
+}
diff --git a/backend/cmd/cmd.go b/backend/cmd/cmd.go
new file mode 100644
index 0000000..dd00166
--- /dev/null
+++ b/backend/cmd/cmd.go
@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"s-ui/config"
+)
+
+func ParseCmd() {
+	var showVersion bool
+	flag.BoolVar(&showVersion, "v", false, "show version")
+
+	adminCmd := flag.NewFlagSet("admin", flag.ExitOnError)
+	settingCmd := flag.NewFlagSet("setting", flag.ExitOnError)
+
+	var username string
+	var password string
+	var port int
+	var path string
+	var subPort int
+	var subPath string
+	var reset bool
+	var show bool
+	settingCmd.BoolVar(&reset, "reset", false, "reset all settings")
+	settingCmd.BoolVar(&show, "show", false, "show current settings")
+	settingCmd.IntVar(&port, "port", 0, "set panel port")
+	settingCmd.StringVar(&path, "path", "", "set panel path")
+	settingCmd.IntVar(&subPort, "subPort", 0, "set sub port")
+	settingCmd.StringVar(&subPath, "subPath", "", "set sub path")
+
+	adminCmd.BoolVar(&show, "show", false, "show first admin credentials")
+	adminCmd.BoolVar(&reset, "reset", false, "reset first admin credentials")
+	adminCmd.StringVar(&username, "username", "", "set login username")
+	adminCmd.StringVar(&password, "password", "", "set login password")
+
+	oldUsage := flag.Usage
+	flag.Usage = func() {
+		oldUsage()
+		fmt.Println()
+		fmt.Println("Commands:")
+		fmt.Println("    admin          set/reset/show first admin credentials")
+		fmt.Println("    setting        set/reset/show settings")
+		fmt.Println()
+		adminCmd.Usage()
+		fmt.Println()
+		settingCmd.Usage()
+	}
+
+	flag.Parse()
+	if showVersion {
+		fmt.Println(config.GetVersion())
+		return
+	}
+
+	switch os.Args[1] {
+	case "admin":
+		err := adminCmd.Parse(os.Args[2:])
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		switch {
+		case show:
+			showAdmin()
+		case reset:
+			resetAdmin()
+		default:
+			updateAdmin(username, password)
+			showAdmin()
+		}
+
+	case "setting":
+		err := settingCmd.Parse(os.Args[2:])
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		switch {
+		case show:
+			showSetting()
+		case reset:
+			resetSetting()
+		default:
+			updateSetting(port, path, subPort, subPath)
+			showSetting()
+		}
+	default:
+		fmt.Println("Invalid subcommands")
+		flag.Usage()
+	}
+}
diff --git a/backend/cmd/setting.go b/backend/cmd/setting.go
new file mode 100644
index 0000000..7765f16
--- /dev/null
+++ b/backend/cmd/setting.go
@@ -0,0 +1,100 @@
+package cmd
+
+import (
+	"fmt"
+	"s-ui/config"
+	"s-ui/database"
+	"s-ui/service"
+)
+
+func resetSetting() {
+	err := database.InitDB(config.GetDBPath())
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	settingService := service.SettingService{}
+	err = settingService.ResetSettings()
+	if err != nil {
+		fmt.Println("reset setting failed:", err)
+	} else {
+		fmt.Println("reset setting success")
+	}
+}
+
+func updateSetting(port int, path string, subPort int, subPath string) {
+	err := database.InitDB(config.GetDBPath())
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	settingService := service.SettingService{}
+
+	if port > 0 {
+		err := settingService.SetPort(port)
+		if err != nil {
+			fmt.Println("set port failed:", err)
+		} else {
+			fmt.Println("set port success")
+		}
+	}
+	if path != "" {
+		err := settingService.SetWebPath(path)
+		if err != nil {
+			fmt.Println("set path failed:", err)
+		} else {
+			fmt.Println("set path success")
+		}
+	}
+	if subPort > 0 {
+		err := settingService.SetSubPort(subPort)
+		if err != nil {
+			fmt.Println("set sub port failed:", err)
+		} else {
+			fmt.Println("set sub port success")
+		}
+	}
+	if subPath != "" {
+		err := settingService.SetSubPath(subPath)
+		if err != nil {
+			fmt.Println("set sub path failed:", err)
+		} else {
+			fmt.Println("set sub path success")
+		}
+	}
+}
+
+func showSetting() {
+	settingService := service.SettingService{}
+	allSetting, err := settingService.GetAllSetting()
+	if err != nil {
+		fmt.Println("get current port failed,error info:", err)
+	}
+	fmt.Println("Current panel settings:")
+	fmt.Println("\tPanel port:\t", (*allSetting)["webPort"])
+	fmt.Println("\tPanel path:\t", (*allSetting)["webPath"])
+	if (*allSetting)["webListen"] != "" {
+		fmt.Println("\tPanel IP:\t", (*allSetting)["webListen"])
+	}
+	if (*allSetting)["webDomain"] != "" {
+		fmt.Println("\tPanel Domain:\t", (*allSetting)["webDomain"])
+	}
+	if (*allSetting)["webURI"] != "" {
+		fmt.Println("\tPanel URI:\t", (*allSetting)["webURI"])
+	}
+	fmt.Println()
+	fmt.Println("Current subscription settings:")
+	fmt.Println("\tSub port:\t", (*allSetting)["subPort"])
+	fmt.Println("\tSub path:\t", (*allSetting)["subPath"])
+	if (*allSetting)["subListen"] != "" {
+		fmt.Println("\tSub IP:\t", (*allSetting)["subListen"])
+	}
+	if (*allSetting)["subDomain"] != "" {
+		fmt.Println("\tSub Domain:\t", (*allSetting)["subDomain"])
+	}
+	if (*allSetting)["subURI"] != "" {
+		fmt.Println("\tSub URI:\t", (*allSetting)["subURI"])
+	}
+}
diff --git a/backend/main.go b/backend/main.go
index 092a6fb..4351746 100644
--- a/backend/main.go
+++ b/backend/main.go
@@ -5,10 +5,11 @@ import (
 	"os"
 	"os/signal"
 	"s-ui/app"
+	"s-ui/cmd"
 	"syscall"
 )
 
-func main() {
+func runApp() {
 	app := app.NewApp()
 
 	err := app.Init()
@@ -36,3 +37,12 @@ func main() {
 		}
 	}
 }
+
+func main() {
+	if len(os.Args) < 2 {
+		runApp()
+		return
+	} else {
+		cmd.ParseCmd()
+	}
+}
diff --git a/backend/service/setting.go b/backend/service/setting.go
index b8c8383..e1e1a3c 100644
--- a/backend/service/setting.go
+++ b/backend/service/setting.go
@@ -69,6 +69,11 @@ func (s *SettingService) GetAllSetting() (*map[string]string, error) {
 	return &allSetting, nil
 }
 
+func (s *SettingService) ResetSettings() error {
+	db := database.GetDB()
+	return db.Where("1 = 1").Delete(model.Setting{}).Error
+}
+
 func (s *SettingService) getSetting(key string) (*model.Setting, error) {
 	db := database.GetDB()
 	setting := &model.Setting{}
@@ -174,6 +179,16 @@ func (s *SettingService) GetWebPath() (string, error) {
 	return webPath, nil
 }
 
+func (s *SettingService) SetWebPath(webPath string) error {
+	if !strings.HasPrefix(webPath, "/") {
+		webPath = "/" + webPath
+	}
+	if !strings.HasSuffix(webPath, "/") {
+		webPath += "/"
+	}
+	return s.setString("webPath", webPath)
+}
+
 func (s *SettingService) GetSecret() ([]byte, error) {
 	secret, err := s.getString("webSecret")
 	if secret == defaultValueMap["webSecret"] {
@@ -211,6 +226,10 @@ func (s *SettingService) GetSubPort() (int, error) {
 	return s.getInt("subPort")
 }
 
+func (s *SettingService) SetSubPort(subPort int) error {
+	return s.setInt("subPort", subPort)
+}
+
 func (s *SettingService) GetSubPath() (string, error) {
 	subPath, err := s.getString("subPath")
 	if err != nil {
@@ -225,6 +244,16 @@ func (s *SettingService) GetSubPath() (string, error) {
 	return subPath, nil
 }
 
+func (s *SettingService) SetSubPath(subPath string) error {
+	if !strings.HasPrefix(subPath, "/") {
+		subPath = "/" + subPath
+	}
+	if !strings.HasSuffix(subPath, "/") {
+		subPath += "/"
+	}
+	return s.setString("subPath", subPath)
+}
+
 func (s *SettingService) GetSubDomain() (string, error) {
 	return s.getString("subDomain")
 }
diff --git a/backend/service/user.go b/backend/service/user.go
index 0a1a7c7..6e2920d 100644
--- a/backend/service/user.go
+++ b/backend/service/user.go
@@ -13,6 +13,40 @@ import (
 type UserService struct {
 }
 
+func (s *UserService) GetFirstUser() (*model.User, error) {
+	db := database.GetDB()
+
+	user := &model.User{}
+	err := db.Model(model.User{}).
+		First(user).
+		Error
+	if err != nil {
+		return nil, err
+	}
+	return user, nil
+}
+
+func (s *UserService) UpdateFirstUser(username string, password string) error {
+	if username == "" {
+		return common.NewError("username can not be empty")
+	} else if password == "" {
+		return common.NewError("password can not be empty")
+	}
+	db := database.GetDB()
+	user := &model.User{}
+	err := db.Model(model.User{}).First(user).Error
+	if database.IsNotFound(err) {
+		user.Username = username
+		user.Password = password
+		return db.Model(model.User{}).Create(user).Error
+	} else if err != nil {
+		return err
+	}
+	user.Username = username
+	user.Password = password
+	return db.Save(user).Error
+}
+
 func (s *UserService) Login(username string, password string, remoteIP string) (string, error) {
 	user := s.CheckUser(username, password, remoteIP)
 	if user == nil {