Go CLI: Fix alter role (#16226)

### What problem does this PR solve?

As title.

### Type of change

- [x] Bug Fix (non-breaking change which fixes an issue)

---------

Signed-off-by: Jin Hai <haijin.chn@gmail.com>

internal/cli/admin_command.go

@@ -252,7 +252,7 @@ func (c *CLI) AdminAlterRole(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("failed to alter role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
 	}
 
-	var result SimpleResponse
+	var result CommonDataResponse
 
 	if err = json.Unmarshal(resp.Body, &result); err != nil {
 		return nil, fmt.Errorf("alter role failed: invalid JSON (%w)", err)
@@ -265,8 +265,8 @@ func (c *CLI) AdminAlterRole(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-// GrantAdmin grants admin privileges to a user (admin mode only)
-func (c *CLI) GrantAdmin(cmd *Command) (ResponseIf, error) {
+// AdminGrantUserAdminCommand grants admin privileges to a user (admin mode only)
+func (c *CLI) AdminGrantUserAdminCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
 		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
 	}
@@ -301,8 +301,8 @@ func (c *CLI) GrantAdmin(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-// RevokeAdmin revokes admin privileges from a user (admin mode only)
-func (c *CLI) RevokeAdmin(cmd *Command) (ResponseIf, error) {
+// AdminRevokeUserAdminCommand revokes admin privileges from a user (admin mode only)
+func (c *CLI) AdminRevokeUserAdminCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
 		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
 	}
@@ -337,6 +337,140 @@ func (c *CLI) RevokeAdmin(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
+// AdminGrantRolePermissionCommand grants permission to role (admin mode only)
+func (c *CLI) AdminGrantRolePermissionCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	actions, ok := cmd.Params["actions"].([]string)
+	if !ok {
+		return nil, fmt.Errorf("actions not provided")
+	}
+
+	resource, ok := cmd.Params["resource"].(string)
+	if !ok {
+		return nil, fmt.Errorf("resource not provided")
+	}
+
+	roleName, ok := cmd.Params["role_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("role_name not provided")
+	}
+
+	payload := map[string]interface{}{
+		"actions":  actions,
+		"resource": resource,
+	}
+
+	apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName)
+
+	resp, err := c.AdminServerClient.Request("POST", apiURL, "admin", nil, payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to grant permission to role: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to grant permission to role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("grant permission to role failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+// AdminRevokeRolePermissionCommand revokes permission from role (admin mode only)
+func (c *CLI) AdminRevokeRolePermissionCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	actions, ok := cmd.Params["actions"].([]string)
+	if !ok {
+		return nil, fmt.Errorf("actions not provided")
+	}
+
+	resource, ok := cmd.Params["resource"].(string)
+	if !ok {
+		return nil, fmt.Errorf("resource not provided")
+	}
+
+	roleName, ok := cmd.Params["role_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("role_name not provided")
+	}
+
+	payload := map[string]interface{}{
+		"actions":  actions,
+		"resource": resource,
+	}
+
+	apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName)
+
+	resp, err := c.AdminServerClient.Request("DELETE", apiURL, "admin", nil, payload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to revoke permission from role: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to revoke permission from role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("revoke permission from role failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+// AdminShowRolePermissionCommand shows admin privileges from a user (admin mode only)
+func (c *CLI) AdminShowRolePermissionCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	roleName, ok := cmd.Params["role_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("role_name not provided")
+	}
+
+	apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName)
+
+	resp, err := c.AdminServerClient.Request("GET", apiURL, "admin", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to show role permission: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to show role permission: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("show role permission failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
 // AdminCreateUserCommand creates a new user (admin mode only)
 func (c *CLI) AdminCreateUserCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
@@ -563,27 +697,112 @@ func (c *CLI) AdminListServicesCommand(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
+// AdminStartServiceCommand starts a service (admin mode only)
+func (c *CLI) AdminStartServiceCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	serviceIndex := cmd.Params["service_index"].(int)
+
+	endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex)
+
+	resp, err := c.AdminServerClient.Request("POST", endPoint, "admin", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start service: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to start service: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("start service failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+// AdminRestartServiceCommand restarts a service (admin mode only)
+func (c *CLI) AdminRestartServiceCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	serviceIndex := cmd.Params["service_index"].(int)
+
+	endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex)
+
+	resp, err := c.AdminServerClient.Request("PUT", endPoint, "admin", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to restart service: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to restart service: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("restart service failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
+// AdminShutdownServiceCommand shuts down a service (admin mode only)
+func (c *CLI) AdminShutdownServiceCommand(cmd *Command) (ResponseIf, error) {
+	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
+		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
+	}
+
+	serviceIndex := cmd.Params["service_index"].(int)
+
+	endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex)
+
+	resp, err := c.AdminServerClient.Request("DELETE", endPoint, "admin", nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to shutdown service: %w", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to shutdown service: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
+	}
+
+	var result CommonDataResponse
+	if err = json.Unmarshal(resp.Body, &result); err != nil {
+		return nil, fmt.Errorf("shutdown service failed: invalid JSON (%w)", err)
+	}
+
+	if result.Code != 0 {
+		return nil, fmt.Errorf("%s", result.Message)
+	}
+
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
 // AdminShowService show service (admin mode only)
 func (c *CLI) AdminShowService(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
 		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
 	}
 
-	serviceIndex := cmd.Params["number"].(int)
-
-	// Check for benchmark iterations
-	iterations := 1
-	if val, ok := cmd.Params["iterations"].(int); ok && val > 1 {
-		iterations = val
-	}
+	serviceIndex := cmd.Params["service_index"].(int)
 
 	endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex)
 
-	if iterations > 1 {
-		// Benchmark mode - return raw result for benchmark stats
-		return c.AdminServerClient.RequestWithIterations("GET", endPoint, "admin", nil, nil, iterations)
-	}
-
 	resp, err := c.AdminServerClient.Request("GET", endPoint, "admin", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to show service: %w", err)
@@ -1031,46 +1250,6 @@ func (c *CLI) ShowUserPermission(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-// GenerateAdminToken generates an API token for a user (admin mode only)
-func (c *CLI) GenerateAdminToken(cmd *Command) (ResponseIf, error) {
-	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
-		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
-	}
-
-	userName, ok := cmd.Params["user_name"].(string)
-	if !ok {
-		return nil, fmt.Errorf("user_name not provided")
-	}
-
-	encodedUserName := common.EncodeEmail(userName)
-	apiURL := fmt.Sprintf("/admin/users/%s/keys", encodedUserName)
-
-	resp, err := c.AdminServerClient.Request("POST", apiURL, "admin", nil, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate token: %w", err)
-	}
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("failed to generate token: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
-	}
-
-	var result CommonDataResponse
-	if err = json.Unmarshal(resp.Body, &result); err != nil {
-		return nil, fmt.Errorf("generate token failed: invalid JSON (%w)", err)
-	}
-
-	if result.Code != 0 {
-		return nil, fmt.Errorf("%s", result.Message)
-	}
-
-	delete(result.Data, "update_date")
-	delete(result.Data, "update_time")
-	delete(result.Data, "create_time")
-
-	result.Duration = resp.Duration
-	return &result, nil
-}
-
 func (c *CLI) ListAdminTasks(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
 		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
@@ -1394,41 +1573,6 @@ func (c *CLI) UserShowMessageQueueCommand(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *CLI) AdminRemoveServiceCommand(cmd *Command) (ResponseIf, error) {
-	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {
-		return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login")
-	}
-	serviceNumber, ok := cmd.Params["service_number"].(int)
-	if !ok {
-		return nil, fmt.Errorf("service_number not provided")
-	}
-
-	payload := map[string]interface{}{
-		"service_number": serviceNumber,
-	}
-
-	resp, err := c.AdminServerClient.Request("DELETE", "/admin/services", "admin", nil, payload)
-	if err != nil {
-		return nil, fmt.Errorf("failed to remove unavailable service: %w", err)
-	}
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("failed to remove unavailable service: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
-	}
-
-	var result SimpleResponse
-	if err = json.Unmarshal(resp.Body, &result); err != nil {
-		return nil, fmt.Errorf("remove unavailable service failed: invalid JSON (%w)", err)
-	}
-
-	if result.Code != 0 {
-		return nil, fmt.Errorf("%s", result.Message)
-	}
-
-	result.Duration = resp.Duration
-	return &result, nil
-}
-
 // AdminCheckLicenseCommand check license command (admin mode only)
 func (c *CLI) AdminCheckLicenseCommand(cmd *Command) (ResponseIf, error) {
 	if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil {

internal/cli/admin_parser.go

@@ -50,7 +50,7 @@ func (p *Parser) parseAdminLoginUser() (*Command, error) {
 		p.nextToken()
 	}
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -61,7 +61,7 @@ func (p *Parser) parseAdminLoginUser() (*Command, error) {
 func (p *Parser) parseAdminLogout() (*Command, error) {
 	cmd := NewCommand("logout")
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -71,7 +71,7 @@ func (p *Parser) parseAdminLogout() (*Command, error) {
 func (p *Parser) parseAdminPingServer() (*Command, error) {
 	cmd := NewCommand("ping_server")
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -208,7 +208,7 @@ func (p *Parser) parseAdminListFiles() (*Command, error) {
 	cmd.Params["dataset_name"] = datasetName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -232,7 +232,7 @@ func (p *Parser) parseAdminListIngestionTasks() (*Command, error) {
 
 	cmd := NewCommand("list_admin_ingestion_tasks")
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -321,16 +321,16 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) {
 
 func (p *Parser) parseAdminShowService() (*Command, error) {
 	p.nextToken() // consume SERVICE
-	serviceNum, err := p.parseNumber()
+	serviceIndex, err := p.parseNumber()
 	if err != nil {
 		return nil, err
 	}
 
 	cmd := NewCommand("admin_show_service")
-	cmd.Params["number"] = serviceNum
+	cmd.Params["service_index"] = serviceIndex
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -538,12 +538,19 @@ func (p *Parser) parseAdminShowRole() (*Command, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	cmd := NewCommand("admin_show_role")
-	cmd.Params["role_name"] = roleName
-
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+
+	var cmd *Command
+	if p.curToken.Type == TokenPermission {
+		p.nextToken()
+		cmd = NewCommand("admin_show_role_permission")
+		cmd.Params["role_name"] = roleName
+	} else {
+		cmd = NewCommand("admin_show_role")
+		cmd.Params["role_name"] = roleName
+	}
+
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -574,7 +581,7 @@ func (p *Parser) parseAdminShowVariable() (*Command, error) {
 	cmd.Params["var_name"] = varName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -694,7 +701,7 @@ func (p *Parser) parseCommonShowPoolModel() (*Command, error) {
 		cmd := NewCommand("show_pool_provider")
 		cmd.Params["provider_name"] = providerName
 		p.nextToken()
-		// Semicolon is optional for UNSET TOKEN
+		// Semicolon is optional
 		if p.curToken.Type == TokenSemicolon {
 			p.nextToken()
 		}
@@ -718,7 +725,7 @@ func (p *Parser) parseCommonShowPoolModel() (*Command, error) {
 		cmd := NewCommand("show_pool_model")
 		cmd.Params["provider_name"] = providerName
 		cmd.Params["model_name"] = modelName
-		// Semicolon is optional for UNSET TOKEN
+		// Semicolon is optional
 		if p.curToken.Type == TokenSemicolon {
 			p.nextToken()
 		}
@@ -752,6 +759,7 @@ func (p *Parser) parseAdminCheckLicense() (*Command, error) {
 	return cmd, nil
 }
 
+// STOP INGESTION TASKS 'task_id1 task_id2';
 func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) {
 	p.nextToken() // consume STOP
 
@@ -781,7 +789,7 @@ func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) {
 		return nil, fmt.Errorf("expected USER or INGESTION")
 	}
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -790,7 +798,7 @@ func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) {
 }
 
 func (p *Parser) parseAdminRemoveIngestionTasks() (*Command, error) {
-	p.nextToken() // consume Ingestion
+	p.nextToken() // consume INGESTION
 
 	if p.curToken.Type != TokenTasks {
 		return nil, fmt.Errorf("expected TASKS")
@@ -808,7 +816,7 @@ func (p *Parser) parseAdminRemoveIngestionTasks() (*Command, error) {
 	cmd := NewCommand("admin_remove_ingestion_tasks")
 	cmd.Params["tasks"] = tasks
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -858,7 +866,7 @@ func (p *Parser) parseAdminCreateUser() (*Command, error) {
 		return nil, fmt.Errorf("expected password or KEY after USER, got %s", p.curToken.Value)
 	}
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -903,7 +911,7 @@ func (p *Parser) parseAdminCreateRole() (*Command, error) {
 		p.nextToken()
 	}
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -982,7 +990,7 @@ func (p *Parser) parseAdminDropRole() (*Command, error) {
 	cmd.Params["role_name"] = roleName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1005,7 +1013,7 @@ func (p *Parser) parseAdminDropModelProvider() (*Command, error) {
 	cmd.Params["provider_name"] = providerName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1023,7 +1031,7 @@ func (p *Parser) parseAdminDropDataset() (*Command, error) {
 	cmd.Params["dataset_name"] = datasetName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1041,7 +1049,7 @@ func (p *Parser) parseAdminDropChat() (*Command, error) {
 	cmd.Params["chat_name"] = chatName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1089,7 +1097,7 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) {
 		cmd.Params["password"] = password
 
 		p.nextToken()
-		// Semicolon is optional for SHOW TOKEN
+		// Semicolon is optional
 		if p.curToken.Type == TokenSemicolon {
 			p.nextToken()
 		}
@@ -1121,7 +1129,34 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) {
 	cmd.Params["role_name"] = roleName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
+	if p.curToken.Type == TokenSemicolon {
+		p.nextToken()
+	}
+	return cmd, nil
+}
+
+func (p *Parser) parseAdminActivateUser() (*Command, error) {
+	p.nextToken() // consume ACTIVE
+
+	userName, err := p.parseQuotedString()
+	if err != nil {
+		return nil, err
+	}
+	p.nextToken()
+
+	// Accept 'on' or 'off' as identifier
+	status := p.curToken.Value
+	if status != "on" && status != "off" {
+		return nil, fmt.Errorf("expected 'on' or 'off', got %s", p.curToken.Value)
+	}
+	p.nextToken()
+
+	cmd := NewCommand("admin_activate_user")
+	cmd.Params["user_name"] = userName
+	cmd.Params["activate_status"] = status
+
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1130,16 +1165,18 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) {
 
 func (p *Parser) parseAdminAlterRole() (*Command, error) {
 	p.nextToken() // consume ROLE
-	roleName, err := p.parseIdentifier()
+
+	roleName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
-
 	p.nextToken()
+
 	if p.curToken.Type != TokenSet {
 		return nil, fmt.Errorf("expected SET")
 	}
 	p.nextToken()
+
 	if p.curToken.Type != TokenDescription {
 		return nil, fmt.Errorf("expected DESCRIPTION")
 	}
@@ -1149,13 +1186,13 @@ func (p *Parser) parseAdminAlterRole() (*Command, error) {
 	if err != nil {
 		return nil, err
 	}
+	p.nextToken()
 
-	cmd := NewCommand("alter_role")
+	cmd := NewCommand("admin_alter_role")
 	cmd.Params["role_name"] = roleName
 	cmd.Params["description"] = description
 
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1163,33 +1200,8 @@ func (p *Parser) parseAdminAlterRole() (*Command, error) {
 }
 
 // endregion ALTER commands
-func (p *Parser) parseAdminActivateUser() (*Command, error) {
-	p.nextToken() // consume ACTIVE
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
 
-	p.nextToken()
-	// Accept 'on' or 'off' as identifier
-	status := p.curToken.Value
-	if status != "on" && status != "off" {
-		return nil, fmt.Errorf("expected 'on' or 'off', got %s", p.curToken.Value)
-	}
-
-	cmd := NewCommand("admin_activate_user")
-	cmd.Params["user_name"] = userName
-	cmd.Params["activate_status"] = status
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseAdminGrantCommand() (*Command, error) {
+func (p *Parser) parseAdminGrantCommands() (*Command, error) {
 	p.nextToken() // consume GRANT
 
 	if p.curToken.Type == TokenAdmin {
@@ -1206,11 +1218,11 @@ func (p *Parser) parseAdminGrantAdmin() (*Command, error) {
 		return nil, err
 	}
 
-	cmd := NewCommand("grant_admin")
+	cmd := NewCommand("admin_grant_user_admin")
 	cmd.Params["user_name"] = userName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1218,50 +1230,56 @@ func (p *Parser) parseAdminGrantAdmin() (*Command, error) {
 }
 
 func (p *Parser) parseAdminGrantPermission() (*Command, error) {
-	actions, err := p.parseIdentifierList()
+	actionListStr, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
+	actions := strings.Split(actionListStr, ",")
+	p.nextToken()
+	for idx, _ := range actions {
+		actions[idx] = strings.TrimSpace(actions[idx])
+	}
 
 	if p.curToken.Type != TokenOn {
 		return nil, fmt.Errorf("expected ON")
 	}
 	p.nextToken()
 
-	resource, err := p.parseIdentifier()
+	resource, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
-
 	p.nextToken()
+
 	if p.curToken.Type != TokenTo {
 		return nil, fmt.Errorf("expected TO")
 	}
 	p.nextToken()
+
 	if p.curToken.Type != TokenRole {
 		return nil, fmt.Errorf("expected ROLE")
 	}
 	p.nextToken()
 
-	roleName, err := p.parseIdentifier()
+	roleName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := NewCommand("grant_permission")
+	cmd := NewCommand("admin_grant_role_permission")
 	cmd.Params["actions"] = actions
 	cmd.Params["resource"] = resource
 	cmd.Params["role_name"] = roleName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
 	return cmd, nil
 }
 
-func (p *Parser) parseAdminRevokeCommand() (*Command, error) {
+func (p *Parser) parseAdminRevokeCommands() (*Command, error) {
 	p.nextToken() // consume REVOKE
 
 	if p.curToken.Type == TokenAdmin {
@@ -1278,11 +1296,11 @@ func (p *Parser) parseAdminRevokeAdmin() (*Command, error) {
 		return nil, err
 	}
 
-	cmd := NewCommand("revoke_admin")
+	cmd := NewCommand("admin_revoke_user_admin")
 	cmd.Params["user_name"] = userName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1290,17 +1308,22 @@ func (p *Parser) parseAdminRevokeAdmin() (*Command, error) {
 }
 
 func (p *Parser) parseAdminRevokePermission() (*Command, error) {
-	actions, err := p.parseIdentifierList()
+	actionListStr, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
+	actions := strings.Split(actionListStr, ",")
+	p.nextToken()
+	for idx, _ := range actions {
+		actions[idx] = strings.TrimSpace(actions[idx])
+	}
 
 	if p.curToken.Type != TokenOn {
 		return nil, fmt.Errorf("expected ON")
 	}
 	p.nextToken()
 
-	resource, err := p.parseIdentifier()
+	resource, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
@@ -1315,18 +1338,18 @@ func (p *Parser) parseAdminRevokePermission() (*Command, error) {
 	}
 	p.nextToken()
 
-	roleName, err := p.parseIdentifier()
+	roleName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := NewCommand("revoke_permission")
+	cmd := NewCommand("admin_revoke_role_permission")
 	cmd.Params["actions"] = actions
 	cmd.Params["resource"] = resource
 	cmd.Params["role_name"] = roleName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1366,8 +1389,6 @@ func (p *Parser) parseAdminSetCommand() (*Command, error) {
 		return p.parseAdminSetVariable()
 	case TokenDefault:
 		return p.parseAdminSetDefault()
-	case TokenToken:
-		return p.parseAdminSetToken()
 	default:
 		return nil, fmt.Errorf("unknown SET target: %s", p.curToken.Value)
 	}
@@ -1413,7 +1434,8 @@ func (p *Parser) parseAdminSetLicense() (*Command, error) {
 
 func (p *Parser) parseAdminSetVariable() (*Command, error) {
 	p.nextToken() // consume VAR
-	varName, err := p.parseIdentifier()
+
+	varName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
 	}
@@ -1429,7 +1451,7 @@ func (p *Parser) parseAdminSetVariable() (*Command, error) {
 	cmd.Params["var_value"] = varValue
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1477,7 +1499,7 @@ func (p *Parser) parseAdminSetDefault() (*Command, error) {
 	}
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1496,7 +1518,7 @@ func (p *Parser) parseAdminSetToken() (*Command, error) {
 	cmd.Params["token"] = tokenValue
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1534,37 +1556,6 @@ func (p *Parser) parseAdminResetCommand() (*Command, error) {
 	cmd := NewCommand("reset_default_model")
 	cmd.Params["model_type"] = modelType
 
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseAdminGenerateCommand() (*Command, error) {
-	p.nextToken() // consume GENERATE
-	if p.curToken.Type != TokenToken {
-		return nil, fmt.Errorf("expected TOKEN")
-	}
-	p.nextToken()
-	if p.curToken.Type != TokenFor {
-		return nil, fmt.Errorf("expected FOR")
-	}
-	p.nextToken()
-	if p.curToken.Type != TokenUser {
-		return nil, fmt.Errorf("expected USER")
-	}
-	p.nextToken()
-
-	userName, err := p.parseQuotedString()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("generate_token")
-	cmd.Params["user_name"] = userName
-
 	p.nextToken()
 	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
@@ -1600,7 +1591,7 @@ func (p *Parser) parseAdminImportCommand() (*Command, error) {
 	cmd.Params["dataset_name"] = datasetName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1634,7 +1625,7 @@ func (p *Parser) parseAdminRetrieveCommand() (*Command, error) {
 	cmd.Params["datasets"] = datasets
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1673,7 +1664,7 @@ func (p *Parser) parseAdminParseDataset() (*Command, error) {
 	cmd.Params["method"] = method
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1706,7 +1697,7 @@ func (p *Parser) parseAdminParseDocs() (*Command, error) {
 	cmd.Params["dataset_name"] = datasetName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1770,62 +1761,63 @@ func (p *Parser) parseAdminUserStatement() (*Command, error) {
 	}
 }
 
-func (p *Parser) parseAdminStartupCommand() (*Command, error) {
-	p.nextToken() // consume STARTUP
+func (p *Parser) parseAdminStartService() (*Command, error) {
+	p.nextToken() // consume START
+
 	if p.curToken.Type != TokenService {
 		return nil, fmt.Errorf("expected SERVICE")
 	}
 	p.nextToken()
 
-	serviceNum, err := p.parseNumber()
+	serviceIndex, err := p.parseNumber()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := NewCommand("startup_service")
-	cmd.Params["number"] = serviceNum
+	cmd := NewCommand("admin_start_service")
+	cmd.Params["service_index"] = serviceIndex
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
 	return cmd, nil
 }
 
-func (p *Parser) parseAdminShutdownCommand() (*Command, error) {
+func (p *Parser) parseAdminShutdownCommands() (*Command, error) {
 	p.nextToken() // consume SHUTDOWN
 
 	switch p.curToken.Type {
 	case TokenService:
-		return p.parseAdminShutdownServiceCommand()
+		return p.parseAdminShutdownService()
 	case TokenIngestor:
-		return p.parseAdminShutdownIngestorCommand()
+		return p.parseAdminShutdownIngestor()
 	default:
 		return nil, fmt.Errorf("expected SERVICE or INGESTOR")
 	}
 }
 
-func (p *Parser) parseAdminShutdownServiceCommand() (*Command, error) {
+func (p *Parser) parseAdminShutdownService() (*Command, error) {
 	p.nextToken() // consume SERVICE
 
-	serviceNum, err := p.parseNumber()
+	serviceIndex, err := p.parseNumber()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := NewCommand("shutdown_service")
-	cmd.Params["number"] = serviceNum
+	cmd := NewCommand("admin_shutdown_service")
+	cmd.Params["service_index"] = serviceIndex
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
 	return cmd, nil
 }
 
-func (p *Parser) parseAdminShutdownIngestorCommand() (*Command, error) {
+func (p *Parser) parseAdminShutdownIngestor() (*Command, error) {
 	p.nextToken() // consume INGESTOR
 
 	ingestorName, err := p.parseQuotedString()
@@ -1837,30 +1829,30 @@ func (p *Parser) parseAdminShutdownIngestorCommand() (*Command, error) {
 	cmd.Params["ingestor_name"] = ingestorName
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
 	return cmd, nil
 }
 
-func (p *Parser) parseAdminRestartCommand() (*Command, error) {
+func (p *Parser) parseAdminRestart() (*Command, error) {
 	p.nextToken() // consume RESTART
 	if p.curToken.Type != TokenService {
 		return nil, fmt.Errorf("expected SERVICE")
 	}
 	p.nextToken()
 
-	serviceNum, err := p.parseNumber()
+	serviceIndex, err := p.parseNumber()
 	if err != nil {
 		return nil, err
 	}
 
-	cmd := NewCommand("restart_service")
-	cmd.Params["number"] = serviceNum
+	cmd := NewCommand("admin_restart_service")
+	cmd.Params["service_index"] = serviceIndex
 
 	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1930,7 +1922,7 @@ func (p *Parser) parseStartIngestion() (*Command, error) {
 	cmd.Params["uri"] = uri
 	p.nextToken()
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1954,7 +1946,7 @@ func (p *Parser) parseStopIngestion() (*Command, error) {
 	cmd.Params["task_id"] = taskID
 	p.nextToken()
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1973,7 +1965,7 @@ func (p *Parser) parseAdminIngestCommand() (*Command, error) {
 	cmd.Params["uri"] = uri
 	p.nextToken()
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -1987,7 +1979,7 @@ func (p *Parser) parseAdminUnsetCommand() (*Command, error) {
 	}
 	p.nextToken()
 
-	// Semicolon is optional for UNSET TOKEN
+	// Semicolon is optional
 	if p.curToken.Type == TokenSemicolon {
 		p.nextToken()
 	}
@@ -2059,20 +2051,12 @@ func (p *Parser) parseMessageQueueCommand() (*Command, error) {
 	return cmd, nil
 }
 
-func (p *Parser) parseAdminRemoveCommand() (*Command, error) {
-	p.nextToken() // consume MESSAGE_QUEUE
+// REMOVE INGESTION TASK 'task_id';
+// REMOVE USER 'user@example.com' INGESTION TASKS 'created';
+func (p *Parser) parseAdminRemoveCommands() (*Command, error) {
+	p.nextToken() // consume REMOVE
 
-	var cmd *Command
 	switch p.curToken.Type {
-	case TokenService:
-		p.nextToken() // consume SERVICE
-		serviceNum, err := p.parseNumber()
-		if err != nil {
-			return nil, fmt.Errorf("expected service number after SERVICE")
-		}
-		p.nextToken() // consume service number
-		cmd = NewCommand("admin_remove_service_command")
-		cmd.Params["service_number"] = serviceNum
 	case TokenIngestion:
 		return p.parseAdminRemoveIngestionTasks()
 	case TokenUser:
@@ -2080,11 +2064,6 @@ func (p *Parser) parseAdminRemoveCommand() (*Command, error) {
 	default:
 		return nil, fmt.Errorf("expected SERVICE")
 	}
-	// Semicolon is optional
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
 }
 
 // SHOW USERS SUMMARY;

internal/cli/cli_http.go

@@ -47,10 +47,22 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
 		return c.RunBenchmark(cmd)
 	case "admin_list_services":
 		return c.AdminListServicesCommand(cmd)
-	case "grant_admin":
-		return c.GrantAdmin(cmd)
-	case "revoke_admin":
-		return c.RevokeAdmin(cmd)
+	case "admin_start_service":
+		return c.AdminStartServiceCommand(cmd)
+	case "admin_restart_service":
+		return c.AdminRestartServiceCommand(cmd)
+	case "admin_shutdown_service":
+		return c.AdminShutdownServiceCommand(cmd)
+	case "admin_grant_user_admin":
+		return c.AdminGrantUserAdminCommand(cmd)
+	case "admin_revoke_user_admin":
+		return c.AdminRevokeUserAdminCommand(cmd)
+	case "admin_grant_role_permission":
+		return c.AdminGrantRolePermissionCommand(cmd)
+	case "admin_revoke_role_permission":
+		return c.AdminRevokeRolePermissionCommand(cmd)
+	case "admin_show_role_permission":
+		return c.AdminShowRolePermissionCommand(cmd)
 	case "admin_create_user":
 		return c.AdminCreateUserCommand(cmd)
 	case "admin_create_user_api_key":
@@ -95,8 +107,6 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
 		return c.AdminListResourcesCommand(cmd)
 	case "admin_list_roles_command":
 		return c.AdminListRolesCommand(cmd)
-	case "generate_token":
-		return c.GenerateAdminToken(cmd)
 	case "admin_list_available_providers":
 		return c.CommonAvailableProvidersCommand(cmd)
 	case "admin_show_provider":
@@ -133,8 +143,6 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
 		return c.UserPullMessageCommand(cmd)
 	case "user_show_message_queue_command":
 		return c.UserShowMessageQueueCommand(cmd)
-	case "admin_remove_service_command":
-		return c.AdminRemoveServiceCommand(cmd)
 	case "admin_check_license":
 		return c.AdminCheckLicenseCommand(cmd)
 	case "admin_show_fingerprint":

internal/cli/parser.go

@@ -99,36 +99,25 @@ func (p *Parser) parseAdminCommand() (*Command, error) {
 	case TokenAlter:
 		return p.parseAdminAlterCommands()
 	case TokenGrant:
-		return p.parseAdminGrantCommand()
+		return p.parseAdminGrantCommands()
 	case TokenRevoke:
-		return p.parseAdminRevokeCommand()
+		return p.parseAdminRevokeCommands()
 	case TokenSet:
 		return p.parseAdminSetCommand()
-	case TokenUnset:
-		return p.parseAdminUnsetCommand()
 	case TokenReset:
 		return p.parseAdminResetCommand()
-	case TokenGenerate:
-		return p.parseAdminGenerateCommand()
-	case TokenImport:
-		return p.parseAdminImportCommand()
-	case TokenRetrieve:
-		return p.parseAdminRetrieveCommand()
-	case TokenParse:
-		return p.parseAdminParseCommand()
 	case TokenBenchmark:
 		return p.parseAdminBenchmarkCommand()
-
-	case TokenStartup:
-		return p.parseAdminStartupCommand()
+	case TokenStart:
+		return p.parseAdminStartService()
 	case TokenShutdown:
-		return p.parseAdminShutdownCommand()
+		return p.parseAdminShutdownCommands()
 	case TokenRestart:
-		return p.parseAdminRestartCommand()
+		return p.parseAdminRestart()
 	case TokenMQ:
 		return p.parseMessageQueueCommand()
 	case TokenRemove:
-		return p.parseAdminRemoveCommand()
+		return p.parseAdminRemoveCommands()
 	case TokenStop:
 		return p.parseAdminStopIngestionTasks()
 	case TokenAdd:
@@ -189,12 +178,6 @@ func (p *Parser) parseUserCommand() (*Command, error) {
 		return p.parseBenchmarkCommand()
 	case TokenRegister:
 		return p.parseRegisterCommand()
-	case TokenStartup:
-		return p.parseStartupCommand()
-	case TokenShutdown:
-		return p.parseShutdownCommand()
-	case TokenRestart:
-		return p.parseRestartCommand()
 	case TokenEnable:
 		return p.parseEnableCommand()
 	case TokenDisable:

internal/cli/user_parser.go

@@ -1009,15 +1009,10 @@ optionsLoop:
 	return cmd, nil
 }
 
-// syntax: add admin server host '127.0.0.1:9333' user 'ccc' password 'ppp'
+// syntax: add admin host '127.0.0.1:9333' user 'ccc' password 'ppp'
 func (p *Parser) parseAddAdminServer() (*Command, error) {
 	p.nextToken() // consume ADMIN
 
-	if p.curToken.Type != TokenServer {
-		return nil, fmt.Errorf("expected server name")
-	}
-	p.nextToken() // consume SERVER
-
 	if p.curToken.Type != TokenHost {
 		return nil, fmt.Errorf("expected HOST")
 	}
@@ -1041,15 +1036,10 @@ func (p *Parser) parseAddAdminServer() (*Command, error) {
 	return cmd, nil
 }
 
-// syntax: add api server 'abc' host '127.0.0.1:9333' token 'xxx' user 'ccc' password 'ppp'
+// syntax: add api 'abc' host '127.0.0.1:9333' token 'xxx' user 'ccc' password 'ppp'
 func (p *Parser) parseAddAPIServer() (*Command, error) {
 	p.nextToken() // consume API
 
-	if p.curToken.Type != TokenServer {
-		return nil, fmt.Errorf("expected server name")
-	}
-	p.nextToken() // consume SERVER
-
 	serverName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
@@ -1103,15 +1093,10 @@ optionsLoop:
 	return cmd, nil
 }
 
-// syntax: delete api server 'abc'
+// syntax: delete api 'abc'
 func (p *Parser) parseDeleteAPIServer() (*Command, error) {
 	p.nextToken() // consume API
 
-	if p.curToken.Type != TokenServer {
-		return nil, fmt.Errorf("expected server name")
-	}
-	p.nextToken() // consume SERVER
-
 	serverName, err := p.parseQuotedString()
 	if err != nil {
 		return nil, err
@@ -1870,7 +1855,7 @@ func (p *Parser) parseIdentifierList() ([]string, error) {
 
 	for p.curToken.Type == TokenComma {
 		p.nextToken()
-		ident, err := p.parseIdentifier()
+		ident, err = p.parseIdentifier()
 		if err != nil {
 			return nil, err
 		}
@@ -3716,75 +3701,6 @@ func (p *Parser) parseUserStatement() (*Command, error) {
 	}
 }
 
-func (p *Parser) parseStartupCommand() (*Command, error) {
-	p.nextToken() // consume STARTUP
-	if p.curToken.Type != TokenService {
-		return nil, fmt.Errorf("expected SERVICE")
-	}
-	p.nextToken()
-
-	serviceNum, err := p.parseNumber()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("startup_service")
-	cmd.Params["number"] = serviceNum
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseShutdownCommand() (*Command, error) {
-	p.nextToken() // consume SHUTDOWN
-	if p.curToken.Type != TokenService {
-		return nil, fmt.Errorf("expected SERVICE")
-	}
-	p.nextToken()
-
-	serviceNum, err := p.parseNumber()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("shutdown_service")
-	cmd.Params["number"] = serviceNum
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
-func (p *Parser) parseRestartCommand() (*Command, error) {
-	p.nextToken() // consume RESTART
-	if p.curToken.Type != TokenService {
-		return nil, fmt.Errorf("expected SERVICE")
-	}
-	p.nextToken()
-
-	serviceNum, err := p.parseNumber()
-	if err != nil {
-		return nil, err
-	}
-
-	cmd := NewCommand("restart_service")
-	cmd.Params["number"] = serviceNum
-
-	p.nextToken()
-	// Semicolon is optional for UNSET TOKEN
-	if p.curToken.Type == TokenSemicolon {
-		p.nextToken()
-	}
-	return cmd, nil
-}
-
 func (p *Parser) parseUnsetCommand() (*Command, error) {
 	p.nextToken() // consume UNSET