Go: refactor CLI (#15728)

### What problem does this PR solve?

```
RAGFlow(user)> add api server 'ccc' host '127.0.0.1:9980';
SUCCESS
RAGFlow(user)> list api server;
+------------+---------------+-----------------+---------+-------------+---------------+
| api_server | api_server_ip | api_server_port | auth    | user_name   | user_password |
+------------+---------------+-----------------+---------+-------------+---------------+
| ccc        | 127.0.0.1     | 9980            | no auth |             |               |
| default    | 127.0.0.1     | 9384            | login   | aaa@aaa.com | ***           |
+------------+---------------+-----------------+---------+-------------+---------------+
RAGFlow(user)> delete api server 'ccc';
SUCCESS
RAGFlow(user)> list api server;
+------------+---------------+-----------------+---------+
| api_server | api_server_ip | api_server_port | auth    |
+------------+---------------+-----------------+---------+
| default    | 127.0.0.1     | 9384            | no auth |
+------------+---------------+-----------------+---------+

RAGFlow(user)> show admin server;
+--------------+-------+
| field        | value |
+--------------+-------+
| admin_server | N/A   |
+--------------+-------+
RAGFlow(user)> add admin server host '127.0.0.1:9880';
SUCCESS
RAGFlow(user)> show admin server;
+-------------------+-----------+
| field             | value     |
+-------------------+-----------+
| admin_server_ip   | 127.0.0.1 |
| admin_server_port | 9880      |
| auth              | no auth   |
+-------------------+-----------+
RAGFlow(user)> delete admin server;
SUCCESS
RAGFlow(user)> show admin server;
+--------------+-------+
| field        | value |
+--------------+-------+
| admin_server | N/A   |
+--------------+-------+

RAGFlow(user)> show current
+-----------------+-------------+
| field           | value       |
+-----------------+-------------+
| api_server_port | 9384        |
| user_name       | aaa@aaa.com |
| user_password   | ***         |
| mode            | api         |
| verbose         | false       |
| api_server      | default     |
| api_server_ip   | 127.0.0.1   |
| auth            | login       |
| output          | table       |
| interactive     | true        |
+-----------------+-------------+
```
### Type of change

- [x] Refactoring

---------

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

internal/cli/common_command.go

@@ -18,126 +18,50 @@ package cli
 
 import (
 	"bufio"
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"os"
 	"strings"
+	"time"
 
 	"golang.org/x/term"
 )
 
-// LoginUserInteractive performs interactive login with username and password
-func (c *RAGFlowClient) LoginUserInteractive(username, password string) error {
-	// First, ping the server to check if it's available
-	// For admin mode, use /admin/ping with useAPIBase=true
-	// For user mode, use /system/ping with useAPIBase=false
-	var pingPath string
-	if c.ServerType == "admin" {
-		pingPath = "/admin/ping"
-	} else {
-		pingPath = "/system/ping"
+func (c *CLI) LoginUserByCommand(cmd *Command) (ResponseIf, error) {
+	email, ok := cmd.Params["email"].(string)
+	if !ok {
+		return nil, fmt.Errorf("email not provided")
+	}
+	password, ok := cmd.Params["password"].(string)
+	if !ok {
+		password = ""
 	}
 
-	resp, err := c.HTTPClient.Request("GET", pingPath, "web", nil, nil)
+	err := c.LoginUserInteractive(email, password)
+	if err != nil {
+		return nil, err
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.SetOutputFormat(c.outputFormat)
+	result.Message = "Login successful"
+
+	return &result, nil
+}
+
+// LoginUserInteractive performs interactive login with username and password
+func (c *CLI) LoginUserInteractive(email, password string) error {
+	// First, ping the server to check if it's available
+	_, err := c.PingServer(1)
 	if err != nil {
-		fmt.Printf("Error: %v\n", err)
-		fmt.Println("Can't access server for login (connection failed)")
 		return err
 	}
 
-	if resp.StatusCode != 200 {
-		fmt.Println("Server is down")
-		return fmt.Errorf("server is down")
-	}
-
-	// Check response - admin returns JSON with message "pong", user returns plain "pong"
-	resJSON, err := resp.JSON()
-	if err == nil {
-		// Admin mode returns {"code":0,"message":"pong"}
-		if msg, ok := resJSON["message"].(string); !ok || msg != "pong" {
-			fmt.Println("Server is down")
-			return fmt.Errorf("server is down")
-		}
-	} else {
-		// User mode returns plain "pong"
-		if string(resp.Body) != "pong" {
-			fmt.Println("Server is down")
-			return fmt.Errorf("server is down")
-		}
-	}
-
 	// If password is not provided, prompt for it
 	if password == "" {
-		fmt.Printf("password for %s: ", username)
-		var err error
-		password, err = ReadPassword()
-		if err != nil {
-			return fmt.Errorf("failed to read password: %w", err)
-		}
-		password = strings.TrimSpace(password)
-	}
-
-	// Login
-	token, err := c.loginUser(username, password)
-	if err != nil {
-		fmt.Printf("Error: %v\n", err)
-		fmt.Println("Can't access server for login (connection failed)")
-		return err
-	}
-
-	c.HTTPClient.LoginToken = token
-	fmt.Printf("Login user %s successfully\n", username)
-	return nil
-}
-
-// LoginUser performs user login
-func (c *RAGFlowClient) LoginUser(cmd *Command) error {
-	// First, ping the server to check if it's available
-	// For admin mode, use /admin/ping with useAPIBase=true
-	// For user mode, use /system/ping with useAPIBase=false
-	var pingPath string
-	if c.ServerType == "admin" {
-		pingPath = "/admin/ping"
-	} else {
-		pingPath = "/system/ping"
-	}
-
-	resp, err := c.HTTPClient.Request("GET", pingPath, "web", nil, nil)
-	if err != nil {
-		fmt.Printf("Error: %v\n", err)
-		fmt.Println("Can't access server for login (connection failed)")
-		return err
-	}
-
-	if resp.StatusCode != 200 {
-		fmt.Println("Server is down")
-		return fmt.Errorf("server is down")
-	}
-
-	// Check response - admin returns JSON with message "pong", user returns plain "pong"
-	resJSON, err := resp.JSON()
-	if err == nil {
-		// Admin mode returns {"code":0,"message":"pong"}
-		if msg, ok := resJSON["message"].(string); !ok || msg != "pong" {
-			fmt.Println("Server is down")
-			return fmt.Errorf("server is down")
-		}
-	} else {
-		// User mode returns plain "pong"
-		if string(resp.Body) != "pong" {
-			fmt.Println("Server is down")
-			return fmt.Errorf("server is down")
-		}
-	}
-
-	email, ok := cmd.Params["email"].(string)
-	if !ok {
-		return fmt.Errorf("email not provided")
-	}
-
-	password, ok := cmd.Params["password"].(string)
-	if !ok {
-		// Get password from user input (hidden)
 		fmt.Printf("password for %s: ", email)
 		password, err = ReadPassword()
 		if err != nil {
@@ -154,13 +78,87 @@ func (c *RAGFlowClient) LoginUser(cmd *Command) error {
 		return err
 	}
 
-	c.HTTPClient.LoginToken = token
 	fmt.Printf("Login user %s successfully\n", email)
+
+	switch c.Config.CLIMode {
+	case AdminMode:
+		c.AdminServerClient.LoginToken = &token
+		c.Config.AdminClientConfig.AdminName = &email
+		c.Config.AdminClientConfig.AdminPassword = &password
+	case APIMode:
+		c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken = &token
+		c.Config.APIClientConfig.APIServerMap[c.Config.APIClientConfig.CurrentAPIServer].UserName = &email
+		c.Config.APIClientConfig.APIServerMap[c.Config.APIClientConfig.CurrentAPIServer].UserPassword = &password
+	default:
+		return fmt.Errorf("invalid server type")
+	}
 	return nil
 }
 
+func (c *CLI) PingByCommand(cmd *Command) (ResponseIf, error) {
+	iterations := 1
+	if iterationsParam, ok := cmd.Params["iterations"]; ok {
+		iterations = int(iterationsParam.(float64))
+	}
+	return c.PingServer(iterations)
+}
+
+func (c *CLI) PingServer(iterations int) (ResponseIf, error) {
+	var pingPath string
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		pingPath = "/admin/ping"
+		if iterations > 1 {
+			return c.AdminServerClient.RequestWithIterations("GET", pingPath, "web", nil, nil, iterations)
+		}
+		resp, err = c.AdminServerClient.Request("GET", pingPath, "web", nil, nil)
+	case APIMode:
+		pingPath = "/system/ping"
+		if iterations > 1 {
+			return c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].RequestWithIterations("GET", pingPath, "web", nil, nil, iterations)
+		}
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", pingPath, "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		fmt.Println("Can't access server for login (connection failed)")
+		return nil, err
+	}
+
+	if resp.StatusCode != 200 {
+		fmt.Println("Server is down")
+		return nil, fmt.Errorf("server is down")
+	}
+
+	var result SimpleResponse
+	switch c.Config.CLIMode {
+	case AdminMode:
+		if err = json.Unmarshal(resp.Body, &result); err != nil {
+			return nil, fmt.Errorf("list users failed: invalid JSON (%w)", err)
+		}
+	case APIMode:
+		if string(resp.Body) == "pong" {
+			result.Code = 0
+			result.Message = "Pong"
+		} else {
+			result.Code = 1
+			result.Message = "Ping failed"
+		}
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	result.Duration = resp.Duration
+	return &result, nil
+}
+
 // loginUser performs the actual login request
-func (c *RAGFlowClient) loginUser(email, password string) (string, error) {
+func (c *CLI) loginUser(email, password string) (string, error) {
 	// Encrypt password using scrypt (same as Python implementation)
 	encryptedPassword, err := EncryptPassword(password)
 	if err != nil {
@@ -172,14 +170,16 @@ func (c *RAGFlowClient) loginUser(email, password string) (string, error) {
 		"password": encryptedPassword,
 	}
 
-	var path string
-	if c.ServerType == "admin" {
-		path = "/admin/login"
-	} else {
-		path = "/auth/login"
+	var resp *Response
+	switch c.Config.CLIMode {
+	case AdminMode:
+		resp, err = c.AdminServerClient.Request("POST", "/admin/login", "", nil, payload)
+	case APIMode:
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("POST", "/auth/login", "", nil, payload)
+	default:
+		return "", fmt.Errorf("invalid server type")
 	}
 
-	resp, err := c.HTTPClient.Request("POST", path, "", nil, payload)
 	if err != nil {
 		return "", err
 	}
@@ -201,19 +201,25 @@ func (c *RAGFlowClient) loginUser(email, password string) (string, error) {
 	return token, nil
 }
 
-func (c *RAGFlowClient) Logout() (ResponseIf, error) {
-	if c.HTTPClient.LoginToken == "" {
-		return nil, fmt.Errorf("not logged in")
+func (c *CLI) Logout() (ResponseIf, error) {
+
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		if c.AdminServerClient.LoginToken == nil {
+			return nil, fmt.Errorf("not logged in")
+		}
+		resp, err = c.AdminServerClient.Request("POST", "/admin/logout", "web", nil, nil)
+	case APIMode:
+		if c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken == nil {
+			return nil, fmt.Errorf("not logged in")
+		}
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("POST", "/auth/logout", "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
 
-	var path string
-	if c.ServerType == "admin" {
-		path = "/admin/logout"
-	} else {
-		path = "/auth/logout"
-	}
-
-	resp, err := c.HTTPClient.Request("POST", path, "web", nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -227,19 +233,35 @@ func (c *RAGFlowClient) Logout() (ResponseIf, error) {
 		return nil, fmt.Errorf("login failed: %s", result.Message)
 	}
 
+	switch c.Config.CLIMode {
+	case AdminMode:
+		c.AdminServerClient.LoginToken = nil
+		c.Config.AdminClientConfig.AdminName = nil
+		c.Config.AdminClientConfig.AdminPassword = nil
+	case APIMode:
+		c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken = nil
+		c.Config.APIClientConfig.APIServerMap[c.Config.APIClientConfig.CurrentAPIServer].UserName = nil
+		c.Config.APIClientConfig.APIServerMap[c.Config.APIClientConfig.CurrentAPIServer].UserPassword = nil
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ListAvailableProviders(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ListAvailableProviders(cmd *Command) (ResponseIf, error) {
 
-	var endPoint string
-	if c.ServerType == "admin" {
-		endPoint = fmt.Sprintf("/admin/providers?available=true")
-	} else {
-		endPoint = fmt.Sprintf("/providers?available=true")
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		resp, err = c.AdminServerClient.Request("GET", "/admin/providers?available=true", "web", nil, nil)
+	case APIMode:
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", "/providers?available=true", "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
 
-	resp, err := c.HTTPClient.Request("GET", endPoint, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list providers: %w", err)
 	}
@@ -260,20 +282,26 @@ func (c *RAGFlowClient) ListAvailableProviders(cmd *Command) (ResponseIf, error)
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ShowProvider(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ShowProvider(cmd *Command) (ResponseIf, error) {
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("provider_name not provided")
 	}
 
+	var resp *Response
+	var err error
 	var endPoint string
-	if c.ServerType == "admin" {
+	switch c.Config.CLIMode {
+	case AdminMode:
 		endPoint = fmt.Sprintf("/admin/providers/%s", providerName)
-	} else {
+		resp, err = c.AdminServerClient.Request("GET", endPoint, "web", nil, nil)
+	case APIMode:
 		endPoint = fmt.Sprintf("/providers/%s", providerName)
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", endPoint, "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
 
-	resp, err := c.HTTPClient.Request("GET", endPoint, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to show provider: %w", err)
 	}
@@ -294,21 +322,27 @@ func (c *RAGFlowClient) ShowProvider(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ListModels(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ListModels(cmd *Command) (ResponseIf, error) {
 
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("provider_name not provided")
 	}
 
+	var resp *Response
+	var err error
 	var endPoint string
-	if c.ServerType == "admin" {
+	switch c.Config.CLIMode {
+	case AdminMode:
 		endPoint = fmt.Sprintf("/admin/providers/%s/models", providerName)
-	} else {
+		resp, err = c.AdminServerClient.Request("GET", endPoint, "web", nil, nil)
+	case APIMode:
 		endPoint = fmt.Sprintf("/providers/%s/models", providerName)
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", endPoint, "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
 
-	resp, err := c.HTTPClient.Request("GET", endPoint, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list models: %w", err)
 	}
@@ -329,7 +363,7 @@ func (c *RAGFlowClient) ListModels(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ListSupportedModels(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ListSupportedModels(cmd *Command) (ResponseIf, error) {
 
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
@@ -340,14 +374,20 @@ func (c *RAGFlowClient) ListSupportedModels(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("instance_name not provided")
 	}
 
+	var resp *Response
+	var err error
 	var endPoint string
-	if c.ServerType == "admin" {
+	switch c.Config.CLIMode {
+	case AdminMode:
 		endPoint = fmt.Sprintf("/admin/providers/%s/instances/%s/models?supported=true", providerName, instanceName)
-	} else {
+		resp, err = c.AdminServerClient.Request("GET", endPoint, "web", nil, nil)
+	case APIMode:
 		endPoint = fmt.Sprintf("/providers/%s/instances/%s/models?supported=true", providerName, instanceName)
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", endPoint, "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
 
-	resp, err := c.HTTPClient.Request("GET", endPoint, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list models: %w", err)
 	}
@@ -368,7 +408,7 @@ func (c *RAGFlowClient) ListSupportedModels(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ShowProviderModel(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ShowProviderModel(cmd *Command) (ResponseIf, error) {
 	providerName, ok := cmd.Params["provider_name"].(string)
 	if !ok {
 		return nil, fmt.Errorf("provider_name not provided")
@@ -378,14 +418,19 @@ func (c *RAGFlowClient) ShowProviderModel(cmd *Command) (ResponseIf, error) {
 		return nil, fmt.Errorf("model_name not provided")
 	}
 
+	var resp *Response
+	var err error
 	var endPoint string
-	if c.ServerType == "admin" {
+	switch c.Config.CLIMode {
+	case AdminMode:
 		endPoint = fmt.Sprintf("/admin/providers/%s/models/%s", providerName, modelName)
-	} else {
+		resp, err = c.AdminServerClient.Request("GET", endPoint, "web", nil, nil)
+	case APIMode:
 		endPoint = fmt.Sprintf("/providers/%s/models/%s", providerName, modelName)
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", endPoint, "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
 	}
-
-	resp, err := c.HTTPClient.Request("GET", endPoint, "web", nil, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to show model: %w", err)
 	}
@@ -406,7 +451,7 @@ func (c *RAGFlowClient) ShowProviderModel(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) SetDefaultModel(cmd *Command) (ResponseIf, error) {
+func (c *CLI) SetDefaultModel(cmd *Command) (ResponseIf, error) {
 
 	modelType, ok := cmd.Params["model_type"].(string)
 	if !ok {
@@ -434,7 +479,17 @@ func (c *RAGFlowClient) SetDefaultModel(cmd *Command) (ResponseIf, error) {
 		"model_name":     modelName,
 	}
 
-	resp, err := c.HTTPClient.Request("PATCH", "/models", "web", nil, payload)
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		resp, err = c.AdminServerClient.Request("PATCH", "/admin/models", "web", nil, payload)
+	case APIMode:
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("PATCH", "/models", "web", nil, payload)
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
 	if err != nil {
 		return nil, fmt.Errorf("failed to set default model: %w", err)
 	}
@@ -455,7 +510,7 @@ func (c *RAGFlowClient) SetDefaultModel(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ResetDefaultModel(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ResetDefaultModel(cmd *Command) (ResponseIf, error) {
 
 	modelType, ok := cmd.Params["model_type"].(string)
 	if !ok {
@@ -466,7 +521,17 @@ func (c *RAGFlowClient) ResetDefaultModel(cmd *Command) (ResponseIf, error) {
 		"model_type": modelType,
 	}
 
-	resp, err := c.HTTPClient.Request("PATCH", "/models", "web", nil, payload)
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		resp, err = c.AdminServerClient.Request("PATCH", "/admin/models", "web", nil, payload)
+	case APIMode:
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("PATCH", "/models", "web", nil, payload)
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
 	if err != nil {
 		return nil, fmt.Errorf("failed to reset default model: %w", err)
 	}
@@ -487,8 +552,19 @@ func (c *RAGFlowClient) ResetDefaultModel(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ListDefaultModels(cmd *Command) (ResponseIf, error) {
-	resp, err := c.HTTPClient.Request("GET", "/models", "web", nil, nil)
+func (c *CLI) ListDefaultModels(cmd *Command) (ResponseIf, error) {
+
+	var resp *Response
+	var err error
+	switch c.Config.CLIMode {
+	case AdminMode:
+		resp, err = c.AdminServerClient.Request("GET", "/admin/models", "web", nil, nil)
+	case APIMode:
+		resp, err = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].Request("GET", "/models", "web", nil, nil)
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
 	if err != nil {
 		return nil, fmt.Errorf("failed to list default models: %w", err)
 	}
@@ -509,7 +585,308 @@ func (c *RAGFlowClient) ListDefaultModels(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ListAllModels(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ShowCommonCurrent(cmd *Command) (ResponseIf, error) {
+	var result *CommonDataResponse
+
+	switch c.Config.CLIMode {
+	case AdminMode:
+		response, err := c.GetAdminServerInfo()
+		if err != nil {
+			return nil, fmt.Errorf("failed to show current: %w", err)
+		}
+		result = response.(*CommonDataResponse)
+
+	case APIMode:
+		response, err := c.GetAPIServerInfo(c.Config.APIClientConfig.CurrentAPIServer)
+		if err != nil {
+			return nil, err
+		}
+		result = response.(*CommonDataResponse)
+
+		if c.CurrentModel != nil {
+			if result.Data == nil {
+				result.Data = make(map[string]interface{})
+			}
+			result.Data["model_provider"] = c.CurrentModel.Provider
+			result.Data["model_instance"] = c.CurrentModel.Instance
+			result.Data["model_model"] = c.CurrentModel.Model
+		}
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	if result == nil {
+		result = &CommonDataResponse{}
+		if result.Data == nil {
+			result.Data = make(map[string]interface{})
+		}
+	}
+
+	result.Data["mode"] = c.Config.CLIMode
+	result.Data["output"] = c.Config.OutputFormat
+	result.Data["interactive"] = c.Config.Interactive
+	result.Data["verbose"] = c.Config.Verbose
+
+	return result, nil
+}
+
+func (c *CLI) ShowAdminServer(cmd *Command) (ResponseIf, error) {
+	return c.GetAdminServerInfo()
+}
+
+func (c *CLI) ShowAPIServer(cmd *Command) (ResponseIf, error) {
+	apiServerName, ok := cmd.Params["api_server_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("api_server_name not provided")
+	}
+	result, err := c.GetAPIServerInfo(apiServerName)
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (c *CLI) ListAPIServer(cmd *Command) (ResponseIf, error) {
+
+	var result CommonResponse
+	result.Data = make([]map[string]interface{}, 0)
+
+	for serverName, apiServerConfig := range c.Config.APIClientConfig.APIServerMap {
+		element := map[string]interface{}{
+			"api_server": serverName,
+		}
+		element["api_server_ip"] = apiServerConfig.IP
+		element["api_server_port"] = apiServerConfig.Port
+		if apiServerConfig.UserName != nil {
+			element["user_name"] = *apiServerConfig.UserName
+		}
+		if apiServerConfig.UserPassword != nil {
+			element["user_password"] = strings.Repeat("*", len(*apiServerConfig.UserPassword))
+		}
+		if c.APIServerClientMap[serverName].LoginToken != nil {
+			element["auth"] = "login"
+		} else if apiServerConfig.ApiToken != nil {
+			element["auth"] = "api token"
+		} else {
+			element["auth"] = "no auth"
+		}
+		result.Data = append(result.Data, element)
+	}
+
+	return &result, nil
+}
+
+func (c *CLI) AddAPIServer(cmd *Command) (ResponseIf, error) {
+	apiServerName, ok := cmd.Params["server_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("server name not provided")
+	}
+	if c.Config.APIClientConfig.APIServerMap[apiServerName] != nil {
+		return nil, fmt.Errorf("api server already exists")
+	}
+
+	apiServerIP, ok := cmd.Params["server_ip"].(string)
+	if !ok {
+		return nil, fmt.Errorf("server ip not provided")
+	}
+	apiServerPort, ok := cmd.Params["server_port"].(int)
+	if !ok {
+		return nil, fmt.Errorf("server port not provided")
+	}
+	apiServerToken, ok := cmd.Params["server_token"].(string)
+	if !ok {
+		apiServerToken = ""
+	}
+
+	if c.Config.APIClientConfig.APIServerMap == nil {
+		c.Config.APIClientConfig.APIServerMap = make(map[string]*APIServerConfig)
+	}
+
+	c.Config.APIClientConfig.APIServerMap[apiServerName] = &APIServerConfig{
+		Name: apiServerName,
+		IP:   apiServerIP,
+		Port: apiServerPort,
+	}
+	c.Config.APIClientConfig.APIServerMap[apiServerName].IP = apiServerIP
+	c.Config.APIClientConfig.APIServerMap[apiServerName].Port = apiServerPort
+	if apiServerToken != "" {
+		c.Config.APIClientConfig.APIServerMap[apiServerName].ApiToken = &apiServerToken
+	}
+
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+
+	if c.APIServerClientMap == nil {
+		c.APIServerClientMap = make(map[string]*HTTPClient)
+	}
+
+	if c.APIServerClientMap[apiServerName] != nil {
+		return nil, fmt.Errorf("api server: %s already exists", apiServerName)
+	}
+
+	c.APIServerClientMap[apiServerName] = &HTTPClient{
+		Host:           apiServerIP,
+		Port:           apiServerPort,
+		APIVersion:     "v1",
+		ConnectTimeout: 5 * time.Second,
+		ReadTimeout:    60 * time.Second,
+		VerifySSL:      false,
+		client: &http.Client{
+			Transport: transport,
+			Timeout:   300 * time.Second,
+		},
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "api server deleted successfully"
+	result.Duration = 0
+	return &result, nil
+}
+
+func (c *CLI) DeleteAPIServer(cmd *Command) (ResponseIf, error) {
+	apiServerName, ok := cmd.Params["server_name"].(string)
+	if !ok {
+		return nil, fmt.Errorf("server name not provided")
+	}
+	if apiServerName == c.Config.APIClientConfig.CurrentAPIServer {
+		return nil, fmt.Errorf("cannot delete current api server")
+	}
+	delete(c.Config.APIClientConfig.APIServerMap, apiServerName)
+	delete(c.APIServerClientMap, apiServerName)
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "api server deleted successfully"
+	result.Duration = 0
+	return &result, nil
+}
+
+func (c *CLI) AddAdminServer(cmd *Command) (ResponseIf, error) {
+
+	if c.AdminServerClient != nil && c.AdminServerClient.LoginToken != nil {
+		return nil, fmt.Errorf("admin server already login, please logout")
+	}
+
+	adminServerIP, ok := cmd.Params["server_ip"].(string)
+	if !ok {
+		return nil, fmt.Errorf("server ip not provided")
+	}
+	adminServerPort, ok := cmd.Params["server_port"].(int)
+	if !ok {
+		return nil, fmt.Errorf("server port not provided")
+	}
+
+	if c.Config.AdminClientConfig == nil {
+		c.Config.AdminClientConfig = &AdminModeConfig{}
+	}
+
+	if adminServerIP != "" {
+		c.Config.AdminClientConfig.AdminHost = adminServerIP
+	}
+	if adminServerPort != 0 {
+		c.Config.AdminClientConfig.AdminPort = adminServerPort
+	}
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "admin server added successfully"
+	result.Duration = 0
+	return &result, nil
+}
+
+func (c *CLI) DeleteAdminServer(cmd *Command) (ResponseIf, error) {
+
+	if c.AdminServerClient != nil && c.AdminServerClient.LoginToken != nil {
+		return nil, fmt.Errorf("admin server already login, please logout")
+	}
+
+	if c.Config.AdminClientConfig == nil {
+		return nil, fmt.Errorf("admin server not set")
+	}
+
+	c.Config.AdminClientConfig = nil
+
+	var result SimpleResponse
+	result.Code = 0
+	result.Message = "admin server deleted successfully"
+	result.Duration = 0
+	return &result, nil
+}
+
+func (c *CLI) SaveServerConfig(cmd *Command) (ResponseIf, error) {
+
+	switch c.Config.CLIMode {
+	case AdminMode:
+		if c.AdminServerClient.LoginToken == nil {
+			return nil, fmt.Errorf("admin server isn't already login")
+		}
+	case APIMode:
+		if c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].APIToken == nil && c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken == nil {
+			return nil, fmt.Errorf("API token not set. Please login first")
+		}
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	return nil, nil
+}
+
+func (c *CLI) GetAdminServerInfo() (ResponseIf, error) {
+	var result CommonDataResponse
+	result.Data = make(map[string]interface{})
+
+	if c.Config.AdminClientConfig == nil {
+		result.Data["admin_server"] = "N/A"
+	} else {
+		result.Data["admin_server_ip"] = c.Config.AdminClientConfig.AdminHost
+		result.Data["admin_server_port"] = c.Config.AdminClientConfig.AdminPort
+		if c.Config.AdminClientConfig.AdminName != nil {
+			result.Data["admin_name"] = *c.Config.AdminClientConfig.AdminName
+		}
+		if c.Config.AdminClientConfig.AdminPassword != nil {
+			result.Data["admin_password"] = strings.Repeat("*", len(*c.Config.AdminClientConfig.AdminPassword))
+		}
+		if c.AdminServerClient == nil || c.AdminServerClient.LoginToken == nil {
+			result.Data["auth"] = "no auth"
+		} else {
+			result.Data["auth"] = "login"
+		}
+	}
+
+	return &result, nil
+}
+
+func (c *CLI) GetAPIServerInfo(serverName string) (ResponseIf, error) {
+	var result CommonDataResponse
+	result.Data = make(map[string]interface{})
+
+	if c.Config.APIClientConfig.APIServerMap == nil || c.Config.APIClientConfig.APIServerMap[serverName] == nil {
+		result.Data["api_server"] = "N/A"
+	} else {
+		result.Data["api_server"] = serverName
+		apiServerConfig := c.Config.APIClientConfig.APIServerMap[serverName]
+		result.Data["api_server_ip"] = apiServerConfig.IP
+		result.Data["api_server_port"] = apiServerConfig.Port
+		if apiServerConfig.UserName != nil {
+			result.Data["user_name"] = *apiServerConfig.UserName
+		}
+
+		if apiServerConfig.UserPassword != nil {
+			result.Data["user_password"] = strings.Repeat("*", len(*apiServerConfig.UserPassword))
+		}
+		if c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer].LoginToken != nil {
+			result.Data["auth"] = "login"
+		} else if apiServerConfig.ApiToken != nil {
+			result.Data["auth"] = "api token"
+		} else {
+			result.Data["auth"] = "no auth"
+		}
+	}
+	return &result, nil
+}
+
+func (c *CLI) ListAllModels(cmd *Command) (ResponseIf, error) {
 
 	page, ok := cmd.Params["page"].(int)
 	if !ok {
@@ -526,7 +903,17 @@ func (c *RAGFlowClient) ListAllModels(cmd *Command) (ResponseIf, error) {
 		"page_size": pageSize,
 	}
 
-	resp, err := c.HTTPClient.Request("GET", "/all-models", "web", nil, payload)
+	var httpClient *HTTPClient
+	switch c.Config.CLIMode {
+	case AdminMode:
+		httpClient = c.AdminServerClient
+	case APIMode:
+		httpClient = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	resp, err := httpClient.Request("GET", "/all-models", "web", nil, payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list all models: %w", err)
 	}
@@ -547,7 +934,7 @@ func (c *RAGFlowClient) ListAllModels(cmd *Command) (ResponseIf, error) {
 	return &result, nil
 }
 
-func (c *RAGFlowClient) ShowModel(cmd *Command) (ResponseIf, error) {
+func (c *CLI) ShowModel(cmd *Command) (ResponseIf, error) {
 
 	modelName, ok := cmd.Params["model_name"].(string)
 	if !ok {
@@ -558,7 +945,17 @@ func (c *RAGFlowClient) ShowModel(cmd *Command) (ResponseIf, error) {
 		"model_name": modelName,
 	}
 
-	resp, err := c.HTTPClient.Request("GET", "/all-models", "web", nil, payload)
+	var httpClient *HTTPClient
+	switch c.Config.CLIMode {
+	case AdminMode:
+		httpClient = c.AdminServerClient
+	case APIMode:
+		httpClient = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer]
+	default:
+		return nil, fmt.Errorf("invalid server type")
+	}
+
+	resp, err := httpClient.Request("GET", "/all-models", "web", nil, payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to show model: %w", err)
 	}