Update model name to include release date in API handlers

- Consolidated `TokenStorage` struct into `internal/auth/models.go` for better organization.
- Updated `Client` to use `TokenStorage` for managing email and project ID.
- Simplified `SetupUser` method to ensure proper token and project assignment.
- Refactored API handlers to leverage new `GetEmail` and `GetProjectID` methods in `Client`.
- Cleanup: Removed unused structures and redundant code from `client.go` and `auth.go`.
- Adjusted CLI flow in `login.go` and `run.go` for streamlined user onboarding.

internal/api/handlers.go

@@ -62,7 +62,7 @@ func (h *APIHandlers) Models(c *gin.Context) {
 				"id":                    "gemini-2.5-pro-preview-06-05",
 				"object":                "model",
 				"version":               "2.5-preview-06-05",
-				"name":                  "Gemini 2.5 Pro Preview",
+				"name":                  "Gemini 2.5 Pro Preview 06-05",
 				"description":           "Preview release (June 5th, 2025) of Gemini 2.5 Pro",
 				"context_length":        1048576,
 				"max_completion_tokens": 65536,
@@ -407,7 +407,7 @@ func (h *APIHandlers) handleNonStreamingResponse(c *gin.Context, rawJson []byte)
 		cliClient.RequestMutex.Lock()
 	}
 
-	log.Debugf("Request use account: %s, project id: %s", cliClient.Email, cliClient.ProjectID)
+	log.Debugf("Request use account: %s, project id: %s", cliClient.GetEmail(), cliClient.GetProjectID())
 	jsonTemplate := `{"id":"","object":"chat.completion","created":123456,"model":"model","choices":[{"index":0,"message":{"role":"assistant","content":null,"reasoning_content":null,"tool_calls":null},"finish_reason":null,"native_finish_reason":null}]}`
 	respChan, errChan := cliClient.SendMessageStream(cliCtx, rawJson, modelName, contents, tools)
 	for {
@@ -501,7 +501,7 @@ func (h *APIHandlers) handleStreamingResponse(c *gin.Context, rawJson []byte) {
 		cliClient.RequestMutex.Lock()
 	}
 
-	log.Debugf("Request use account: %s, project id: %s", cliClient.Email, cliClient.ProjectID)
+	log.Debugf("Request use account: %s, project id: %s", cliClient.GetEmail(), cliClient.GetProjectID())
 	respChan, errChan := cliClient.SendMessageStream(cliCtx, rawJson, modelName, contents, tools)
 	for {
 		select {

internal/auth/auth.go

@@ -7,17 +7,15 @@ import (
 	"fmt"
 	"github.com/luispater/CLIProxyAPI/internal/config"
 	log "github.com/sirupsen/logrus"
+	"github.com/skratchdot/open-golang/open"
 	"github.com/tidwall/gjson"
 	"golang.org/x/net/proxy"
 	"io"
 	"net"
 	"net/http"
 	"net/url"
-	"os"
-	"path/filepath"
 	"time"
 
-	"github.com/skratchdot/open-golang/open"
 	"golang.org/x/oauth2"
 	"golang.org/x/oauth2/google"
 )
@@ -35,13 +33,6 @@ var (
 	}
 )
 
-type TokenStorage struct {
-	Token     any    `json:"token"`
-	ProjectID string `json:"project_id"`
-	Email     string `json:"email"`
-	Auto      bool   `json:"auto"`
-}
-
 // GetAuthenticatedClient configures and returns an HTTP client with OAuth2 tokens.
 // It handles the entire flow: loading, refreshing, and fetching new tokens.
 func GetAuthenticatedClient(ctx context.Context, ts *TokenStorage, cfg *config.Config) (*http.Client, error) {
@@ -96,7 +87,7 @@ func GetAuthenticatedClient(ctx context.Context, ts *TokenStorage, cfg *config.C
 		if err != nil {
 			return nil, fmt.Errorf("failed to get token from web: %w", err)
 		}
-		newTs, errSaveTokenToFile := saveTokenToFile(ctx, conf, token, ts.ProjectID, cfg.AuthDir)
+		newTs, errSaveTokenToFile := createTokenStorage(ctx, conf, token, ts.ProjectID)
 		if errSaveTokenToFile != nil {
 			log.Errorf("Warning: failed to save token to file: %v", err)
 			return nil, errSaveTokenToFile
@@ -111,8 +102,8 @@ func GetAuthenticatedClient(ctx context.Context, ts *TokenStorage, cfg *config.C
 	return conf.Client(ctx, token), nil
 }
 
-// saveTokenToFile saves a token to the local credentials file.
-func saveTokenToFile(ctx context.Context, config *oauth2.Config, token *oauth2.Token, projectID, authDir string) (*TokenStorage, error) {
+// createTokenStorage creates a token storage.
+func createTokenStorage(ctx context.Context, config *oauth2.Config, token *oauth2.Token, projectID string) (*TokenStorage, error) {
 	httpClient := config.Client(ctx, token)
 	req, err := http.NewRequestWithContext(ctx, "GET", "https://www.googleapis.com/oauth2/v1/userinfo?alt=json", nil)
 	if err != nil {
@@ -160,46 +151,9 @@ func saveTokenToFile(ctx context.Context, config *oauth2.Config, token *oauth2.T
 		Email:     emailResult.String(),
 	}
 
-	if err = os.MkdirAll(authDir, 0700); err != nil {
-		return nil, fmt.Errorf("failed to create directory: %w", err)
-	}
-
-	if projectID != "" {
-		log.Infof("Saving credentials to %s", filepath.Join(authDir, fmt.Sprintf("%s-%s.json", emailResult.String(), projectID)))
-
-		f, errCreate := os.Create(filepath.Join(authDir, fmt.Sprintf("%s-%s.json", emailResult.String(), projectID)))
-		if errCreate != nil {
-			return nil, fmt.Errorf("failed to create token file: %w", errCreate)
-		}
-		defer func() {
-			_ = f.Close()
-		}()
-
-		if err = json.NewEncoder(f).Encode(ts); err != nil {
-			return nil, fmt.Errorf("failed to write token to file: %w", err)
-		}
-	}
 	return &ts, nil
 }
 
-func SaveTokenToFile(ts *TokenStorage, cfg *config.Config, auto bool) error {
-	ts.Auto = auto
-	fileName := filepath.Join(cfg.AuthDir, fmt.Sprintf("%s-%s.json", ts.Email, ts.ProjectID))
-	log.Infof("Saving credentials to %s", fileName)
-	f, err := os.Create(fileName)
-	if err != nil {
-		return fmt.Errorf("failed to create token file: %w", err)
-	}
-	defer func() {
-		_ = f.Close()
-	}()
-
-	if err = json.NewEncoder(f).Encode(ts); err != nil {
-		return fmt.Errorf("failed to write token to file: %w", err)
-	}
-	return nil
-}
-
 // getTokenFromWeb starts a local server to handle the OAuth2 flow.
 func getTokenFromWeb(ctx context.Context, config *oauth2.Config) (*oauth2.Token, error) {
 	// Use a channel to pass the authorization code from the HTTP handler to the main function.
@@ -235,9 +189,10 @@ func getTokenFromWeb(ctx context.Context, config *oauth2.Config) (*oauth2.Token,
 
 	// Open the authorization URL in the user's browser.
 	authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline, oauth2.SetAuthURLParam("prompt", "consent"))
-	log.Debugf("CLI login required.\nAttempting to open authentication page in your browser.\nIf it does not open, please navigate to this URL:\n\n%s\n\n", authURL)
+	log.Debugf("CLI login required.\nAttempting to open authentication page in your browser.\nIf it does not open, please navigate to this URL:\n\n%s\n", authURL)
 
-	err := open.Run(authURL)
+	var err error
+	err = open.Run(authURL)
 	if err != nil {
 		log.Errorf("Failed to open browser: %v. Please open the URL manually.", err)
 	}

internal/auth/models.go

@@ -0,0 +1,9 @@
+package auth
+
+type TokenStorage struct {
+	Token     any    `json:"token"`
+	ProjectID string `json:"project_id"`
+	Email     string `json:"email"`
+	Auto      bool   `json:"auto"`
+	Checked   bool   `json:"checked"`
+}

internal/client/client.go

@@ -6,120 +6,76 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/luispater/CLIProxyAPI/internal/auth"
+	"github.com/luispater/CLIProxyAPI/internal/config"
 	log "github.com/sirupsen/logrus"
 	"github.com/tidwall/gjson"
 	"github.com/tidwall/sjson"
 	"golang.org/x/oauth2"
 	"io"
 	"net/http"
+	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 )
 
-// --- Constants ---
 const (
 	codeAssistEndpoint = "https://cloudcode-pa.googleapis.com"
 	apiVersion         = "v1internal"
-	pluginVersion      = "1.0.0"
+	pluginVersion      = "0.1.9"
 )
 
-type ErrorMessage struct {
-	StatusCode int
-	Error      error
-}
-
-type GCPProject struct {
-	Projects []GCPProjectProjects `json:"projects"`
-}
-type GCPProjectLabels struct {
-	GenerativeLanguage string `json:"generative-language"`
-}
-type GCPProjectProjects struct {
-	ProjectNumber  string           `json:"projectNumber"`
-	ProjectID      string           `json:"projectId"`
-	LifecycleState string           `json:"lifecycleState"`
-	Name           string           `json:"name"`
-	Labels         GCPProjectLabels `json:"labels"`
-	CreateTime     time.Time        `json:"createTime"`
-}
-
-type Content struct {
-	Role  string `json:"role"`
-	Parts []Part `json:"parts"`
-}
-
-// Part represents a single part of a message's content.
-type Part struct {
-	Text             string            `json:"text,omitempty"`
-	InlineData       *InlineData       `json:"inlineData,omitempty"`
-	FunctionCall     *FunctionCall     `json:"functionCall,omitempty"`
-	FunctionResponse *FunctionResponse `json:"functionResponse,omitempty"`
-}
-
-type InlineData struct {
-	MimeType string `json:"mime_type,omitempty"`
-	Data     string `json:"data,omitempty"`
-}
-
-// FunctionCall represents a tool call requested by the model.
-type FunctionCall struct {
-	Name string                 `json:"name"`
-	Args map[string]interface{} `json:"args"`
-}
-
-// FunctionResponse represents the result of a tool execution.
-type FunctionResponse struct {
-	Name     string                 `json:"name"`
-	Response map[string]interface{} `json:"response"`
-}
-
-// GenerateContentRequest is the request payload for the streamGenerateContent endpoint.
-type GenerateContentRequest struct {
-	Contents         []Content         `json:"contents"`
-	Tools            []ToolDeclaration `json:"tools,omitempty"`
-	GenerationConfig `json:"generationConfig"`
-}
-
-// GenerationConfig defines model generation parameters.
-type GenerationConfig struct {
-	ThinkingConfig GenerationConfigThinkingConfig `json:"thinkingConfig,omitempty"`
-	Temperature    float64                        `json:"temperature,omitempty"`
-	TopP           float64                        `json:"topP,omitempty"`
-	TopK           float64                        `json:"topK,omitempty"`
-	// Temperature, TopP, TopK, etc. can be added here.
-}
-
-type GenerationConfigThinkingConfig struct {
-	IncludeThoughts bool `json:"include_thoughts,omitempty"`
-}
-
-// ToolDeclaration is the structure for declaring tools to the API.
-// For now, we'll assume a simple structure. A more complete implementation
-// would mirror the OpenAPI schema definition.
-type ToolDeclaration struct {
-	FunctionDeclarations []interface{} `json:"functionDeclarations"`
-}
-
 // Client is the main client for interacting with the CLI API.
 type Client struct {
 	httpClient   *http.Client
-	ProjectID    string
 	RequestMutex sync.Mutex
-	Email        string
+	tokenStorage *auth.TokenStorage
+	cfg          *config.Config
 }
 
 // NewClient creates a new CLI API client.
-func NewClient(httpClient *http.Client) *Client {
+func NewClient(httpClient *http.Client, ts *auth.TokenStorage, cfg *config.Config) *Client {
 	return &Client{
-		httpClient: httpClient,
+		httpClient:   httpClient,
+		tokenStorage: ts,
+		cfg:          cfg,
 	}
 }
 
+func (c *Client) SetProjectID(projectID string) {
+	c.tokenStorage.ProjectID = projectID
+}
+
+func (c *Client) SetIsAuto(auto bool) {
+	c.tokenStorage.Auto = auto
+}
+
+func (c *Client) SetIsChecked(checked bool) {
+	c.tokenStorage.Checked = checked
+}
+
+func (c *Client) IsChecked() bool {
+	return c.tokenStorage.Checked
+}
+
+func (c *Client) IsAuto() bool {
+	return c.tokenStorage.Auto
+}
+
+func (c *Client) GetEmail() string {
+	return c.tokenStorage.Email
+}
+
+func (c *Client) GetProjectID() string {
+	return c.tokenStorage.ProjectID
+}
+
 // SetupUser performs the initial user onboarding and setup.
-func (c *Client) SetupUser(ctx context.Context, email, projectID string, auto bool) (string, error) {
-	c.Email = email
+func (c *Client) SetupUser(ctx context.Context, email, projectID string) error {
+	c.tokenStorage.Email = email
 	log.Info("Performing user onboarding...")
 
 	// 1. LoadCodeAssist
@@ -133,7 +89,7 @@ func (c *Client) SetupUser(ctx context.Context, email, projectID string, auto bo
 	var loadAssistResp map[string]interface{}
 	err := c.makeAPIRequest(ctx, "loadCodeAssist", "POST", loadAssistReqBody, &loadAssistResp)
 	if err != nil {
-		return projectID, fmt.Errorf("failed to load code assist: %w", err)
+		return fmt.Errorf("failed to load code assist: %w", err)
 	}
 
 	// a, _ := json.Marshal(&loadAssistResp)
@@ -169,32 +125,35 @@ func (c *Client) SetupUser(ctx context.Context, email, projectID string, auto bo
 	if onboardProjectID != "" {
 		onboardReqBody["cloudaicompanionProject"] = onboardProjectID
 	} else {
-		return projectID, fmt.Errorf("failed to start user onboarding, need define a project id")
+		return fmt.Errorf("failed to start user onboarding, need define a project id")
 	}
 
-	var lroResp map[string]interface{}
-	err = c.makeAPIRequest(ctx, "onboardUser", "POST", onboardReqBody, &lroResp)
-	if err != nil {
-		return projectID, fmt.Errorf("failed to start user onboarding: %w", err)
-	}
+	for {
+		var lroResp map[string]interface{}
+		err = c.makeAPIRequest(ctx, "onboardUser", "POST", onboardReqBody, &lroResp)
+		if err != nil {
+			return fmt.Errorf("failed to start user onboarding: %w", err)
+		}
+		// a, _ := json.Marshal(&lroResp)
+		// log.Debug(string(a))
 
-	// a, _ = json.Marshal(&lroResp)
-	// log.Debug(string(a))
-
-	// 3. Poll Long-Running Operation (LRO)
-	if done, doneOk := lroResp["done"].(bool); doneOk && done {
-		if project, projectOk := lroResp["response"].(map[string]interface{})["cloudaicompanionProject"].(map[string]interface{}); projectOk {
-			if projectID != "" && !auto {
-				c.ProjectID = projectID
-				log.Infof("Onboarding complete. Project ID: %s is being enforced. Maybe you need to enable 'Gemini for Google Cloud' once in Google Cloud Console.", c.ProjectID)
-			} else {
-				c.ProjectID = project["id"].(string)
-				log.Infof("Onboarding complete. Using Project ID: %s", c.ProjectID)
+		// 3. Poll Long-Running Operation (LRO)
+		done, doneOk := lroResp["done"].(bool)
+		if doneOk && done {
+			if project, projectOk := lroResp["response"].(map[string]interface{})["cloudaicompanionProject"].(map[string]interface{}); projectOk {
+				if projectID != "" {
+					c.tokenStorage.ProjectID = projectID
+				} else {
+					c.tokenStorage.ProjectID = project["id"].(string)
+				}
+				log.Infof("Onboarding complete. Using Project ID: %s", c.tokenStorage.ProjectID)
+				return nil
 			}
-			return c.ProjectID, nil
+		} else {
+			log.Println("Onboarding in progress, waiting 5 seconds...")
+			time.Sleep(5 * time.Second)
 		}
 	}
-	return projectID, fmt.Errorf("failed to get operation name from onboarding response: %v", lroResp)
 }
 
 // makeAPIRequest handles making requests to the CLI API endpoints.
@@ -325,14 +284,14 @@ func (c *Client) SendMessageStream(ctx context.Context, rawJson []byte, model st
 		request.Tools = tools
 
 		requestBody := map[string]interface{}{
-			"project": c.ProjectID, // Assuming ProjectID is available
+			"project": c.tokenStorage.ProjectID, // Assuming ProjectID is available
 			"request": request,
 			"model":   model,
 		}
 
 		byteRequestBody, _ := json.Marshal(requestBody)
 
-		// log.Debug(string(rawJson))
+		// log.Debug(string(byteRequestBody))
 
 		reasoningEffortResult := gjson.GetBytes(rawJson, "reasoning_effort")
 		if reasoningEffortResult.String() == "none" {
@@ -396,6 +355,57 @@ func (c *Client) SendMessageStream(ctx context.Context, rawJson []byte, model st
 	return dataChan, errChan
 }
 
+func (c *Client) CheckCloudAPIIsEnabled() (bool, error) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer func() {
+		c.RequestMutex.Unlock()
+		cancel()
+	}()
+	c.RequestMutex.Lock()
+
+	requestBody := `{"project":"%s","request":{"contents":[{"role":"user","parts":[{"text":"Be concise. What is the capital of France?"}]}],"generationConfig":{"thinkingConfig":{"include_thoughts":false,"thinkingBudget":0}}},"model":"gemini-2.5-flash"}`
+	requestBody = fmt.Sprintf(requestBody, c.tokenStorage.ProjectID)
+	// log.Debug(requestBody)
+	stream, err := c.StreamAPIRequest(ctx, "streamGenerateContent", []byte(requestBody))
+	if err != nil {
+		if err.StatusCode == 403 {
+			errJson := err.Error.Error()
+			codeResult := gjson.Get(errJson, "error.code")
+			if codeResult.Exists() && codeResult.Type == gjson.Number {
+				if codeResult.Int() == 403 {
+					activationUrlResult := gjson.Get(errJson, "error.details.0.metadata.activationUrl")
+					if activationUrlResult.Exists() {
+						log.Warnf(
+							"\n\nPlease activate your account with this url:\n\n%s\n And execute this command again:\n%s --login --project_id %s",
+							activationUrlResult.String(),
+							os.Args[0],
+							c.tokenStorage.ProjectID,
+						)
+					}
+				}
+			}
+			return false, nil
+		}
+		return false, err.Error
+	}
+
+	scanner := bufio.NewScanner(stream)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+	}
+
+	if scannerErr := scanner.Err(); scannerErr != nil {
+		_ = stream.Close()
+	} else {
+		_ = stream.Close()
+	}
+
+	return true, nil
+}
+
 func (c *Client) GetProjectList(ctx context.Context) (*GCPProject, error) {
 	token, err := c.httpClient.Transport.(*oauth2.Transport).Source.Token()
 	req, err := http.NewRequestWithContext(ctx, "GET", "https://cloudresourcemanager.googleapis.com/v1/projects", nil)
@@ -426,6 +436,27 @@ func (c *Client) GetProjectList(ctx context.Context) (*GCPProject, error) {
 	return &project, nil
 }
 
+func (c *Client) SaveTokenToFile() error {
+	if err := os.MkdirAll(c.cfg.AuthDir, 0700); err != nil {
+		return fmt.Errorf("failed to create directory: %v", err)
+	}
+
+	fileName := filepath.Join(c.cfg.AuthDir, fmt.Sprintf("%s-%s.json", c.tokenStorage.Email, c.tokenStorage.ProjectID))
+	log.Infof("Saving credentials to %s", fileName)
+	f, err := os.Create(fileName)
+	if err != nil {
+		return fmt.Errorf("failed to create token file: %w", err)
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+
+	if err = json.NewEncoder(f).Encode(c.tokenStorage); err != nil {
+		return fmt.Errorf("failed to write token to file: %w", err)
+	}
+	return nil
+}
+
 // getClientMetadata returns metadata about the client environment.
 func getClientMetadata() map[string]string {
 	return map[string]string{
@@ -452,9 +483,9 @@ func getUserAgent() string {
 
 // getPlatform returns the OS and architecture in the format expected by the API.
 func getPlatform() string {
-	os := runtime.GOOS
+	goOS := runtime.GOOS
 	arch := runtime.GOARCH
-	switch os {
+	switch goOS {
 	case "darwin":
 		return fmt.Sprintf("DARWIN_%s", strings.ToUpper(arch))
 	case "linux":

internal/client/models.go

@@ -0,0 +1,80 @@
+package client
+
+import "time"
+
+type ErrorMessage struct {
+	StatusCode int
+	Error      error
+}
+
+type GCPProject struct {
+	Projects []GCPProjectProjects `json:"projects"`
+}
+type GCPProjectLabels struct {
+	GenerativeLanguage string `json:"generative-language"`
+}
+type GCPProjectProjects struct {
+	ProjectNumber  string           `json:"projectNumber"`
+	ProjectID      string           `json:"projectId"`
+	LifecycleState string           `json:"lifecycleState"`
+	Name           string           `json:"name"`
+	Labels         GCPProjectLabels `json:"labels"`
+	CreateTime     time.Time        `json:"createTime"`
+}
+
+type Content struct {
+	Role  string `json:"role"`
+	Parts []Part `json:"parts"`
+}
+
+// Part represents a single part of a message's content.
+type Part struct {
+	Text             string            `json:"text,omitempty"`
+	InlineData       *InlineData       `json:"inlineData,omitempty"`
+	FunctionCall     *FunctionCall     `json:"functionCall,omitempty"`
+	FunctionResponse *FunctionResponse `json:"functionResponse,omitempty"`
+}
+
+type InlineData struct {
+	MimeType string `json:"mime_type,omitempty"`
+	Data     string `json:"data,omitempty"`
+}
+
+// FunctionCall represents a tool call requested by the model.
+type FunctionCall struct {
+	Name string                 `json:"name"`
+	Args map[string]interface{} `json:"args"`
+}
+
+// FunctionResponse represents the result of a tool execution.
+type FunctionResponse struct {
+	Name     string                 `json:"name"`
+	Response map[string]interface{} `json:"response"`
+}
+
+// GenerateContentRequest is the request payload for the streamGenerateContent endpoint.
+type GenerateContentRequest struct {
+	Contents         []Content         `json:"contents"`
+	Tools            []ToolDeclaration `json:"tools,omitempty"`
+	GenerationConfig `json:"generationConfig"`
+}
+
+// GenerationConfig defines model generation parameters.
+type GenerationConfig struct {
+	ThinkingConfig GenerationConfigThinkingConfig `json:"thinkingConfig,omitempty"`
+	Temperature    float64                        `json:"temperature,omitempty"`
+	TopP           float64                        `json:"topP,omitempty"`
+	TopK           float64                        `json:"topK,omitempty"`
+	// Temperature, TopP, TopK, etc. can be added here.
+}
+
+type GenerationConfigThinkingConfig struct {
+	IncludeThoughts bool `json:"include_thoughts,omitempty"`
+}
+
+// ToolDeclaration is the structure for declaring tools to the API.
+// For now, we'll assume a simple structure. A more complete implementation
+// would mirror the OpenAPI schema definition.
+type ToolDeclaration struct {
+	FunctionDeclarations []interface{} `json:"functionDeclarations"`
+}

internal/cmd/login.go

@@ -28,8 +28,8 @@ func DoLogin(cfg *config.Config, projectID string) {
 	log.Info("Authentication successful.")
 
 	// 3. Initialize CLI Client
-	cliClient := client.NewClient(httpClient)
-	projectID, err = cliClient.SetupUser(clientCtx, ts.Email, projectID, ts.Auto)
+	cliClient := client.NewClient(httpClient, &ts, cfg)
+	err = cliClient.SetupUser(clientCtx, ts.Email, projectID)
 	if err != nil {
 		if err.Error() == "failed to start user onboarding, need define a project id" {
 			log.Error("failed to start user onboarding")
@@ -52,11 +52,26 @@ func DoLogin(cfg *config.Config, projectID string) {
 			log.Fatalf("failed to complete user setup: %v", err)
 		}
 	} else {
-		auto := ts.ProjectID == ""
-		ts.ProjectID = projectID
-		err = auth.SaveTokenToFile(&ts, cfg, auto)
+		auto := projectID == ""
+		cliClient.SetIsAuto(auto)
+
+		if !cliClient.IsChecked() && !cliClient.IsAuto() {
+			isChecked, checkErr := cliClient.CheckCloudAPIIsEnabled()
+			if checkErr != nil {
+				log.Fatalf("failed to check cloud api is enabled: %v", checkErr)
+				return
+			}
+			cliClient.SetIsChecked(isChecked)
+		}
+
+		if !cliClient.IsChecked() && !cliClient.IsAuto() {
+			return
+		}
+
+		err = cliClient.SaveTokenToFile()
 		if err != nil {
 			log.Fatal(err)
+			return
 		}
 	}
 }

internal/cmd/run.go

@@ -33,7 +33,7 @@ func StartService(cfg *config.Config) {
 		}
 
 		if !info.IsDir() && strings.HasSuffix(info.Name(), ".json") {
-			log.Debugf(path)
+			log.Debugf("Loading token from: %s", path)
 			f, errOpen := os.Open(path)
 			if errOpen != nil {
 				return errOpen
@@ -56,31 +56,8 @@ func StartService(cfg *config.Config) {
 				log.Info("Authentication successful.")
 
 				// 3. Initialize CLI Client
-				cliClient := client.NewClient(httpClient)
-				if _, err = cliClient.SetupUser(clientCtx, ts.Email, ts.ProjectID, ts.Auto); err != nil {
-					if err.Error() == "failed to start user onboarding, need define a project id" {
-						log.Error("failed to start user onboarding")
-						project, errGetProjectList := cliClient.GetProjectList(clientCtx)
-						if errGetProjectList != nil {
-							log.Fatalf("failed to complete user setup: %v", err)
-						} else {
-							log.Infof("Your account %s needs specify a project id.", ts.Email)
-							log.Info("========================================================================")
-							for i := 0; i < len(project.Projects); i++ {
-								log.Infof("Project ID: %s", project.Projects[i].ProjectID)
-								log.Infof("Project Name: %s", project.Projects[i].Name)
-								log.Info("========================================================================")
-							}
-							log.Infof("Please run this command to login again:\n\n%s --login --project_id <project_id>\n", os.Args[0])
-						}
-					} else {
-						// Log as a warning because in some cases, the CLI might still be usable
-						// or the user might want to retry setup later.
-						log.Fatalf("failed to complete user setup: %v", err)
-					}
-				} else {
-					cliClients = append(cliClients, cliClient)
-				}
+				cliClient := client.NewClient(httpClient, &ts, cfg)
+				cliClients = append(cliClients, cliClient)
 			}
 		}
 		return nil