0.3.0

cmd/apply/apply.go

@@ -0,0 +1,18 @@
+package apply
+
+import (
+	"github.com/fosrl/cli/cmd/apply/blueprint"
+	"github.com/spf13/cobra"
+)
+
+func ApplyCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "apply",
+		Short: "Apply commands",
+		Long:  "Apply resources to the Pangolin server",
+	}
+
+	cmd.AddCommand(blueprint.BlueprintCmd())
+
+	return cmd
+}

cmd/apply/blueprint/blueprint.go

@@ -0,0 +1,98 @@
+package blueprint
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/fosrl/cli/internal/api"
+	"github.com/fosrl/cli/internal/config"
+	"github.com/fosrl/newt/logger"
+	"github.com/spf13/cobra"
+)
+
+type BlueprintCmdOpts struct {
+	Name string
+	Path string
+}
+
+func BlueprintCmd() *cobra.Command {
+	opts := BlueprintCmdOpts{}
+
+	cmd := &cobra.Command{
+		Use:   "blueprint",
+		Short: "Apply a blueprint",
+		Long:  "Apply a YAML blueprint to the Pangolin server",
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			if opts.Path == "" {
+				return errors.New("--file is required")
+			}
+
+			if _, err := os.Stat(opts.Path); err != nil {
+				return err
+			}
+
+			// Strip file extension and use file basename path as name
+			if opts.Name == "" {
+				filename := filepath.Base(opts.Path)
+				if before, ok := strings.CutSuffix(filename, ".yaml"); ok {
+					opts.Name = before
+				} else if before, ok := strings.CutSuffix(filename, ".yml"); ok {
+					opts.Name = before
+				} else {
+					opts.Name = filename
+				}
+			}
+
+			if len(opts.Name) < 1 || len(opts.Name) > 255 {
+				return errors.New("name must be between 1-255 characters")
+			}
+
+			return nil
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := applyBlueprintMain(cmd, opts); err != nil {
+				os.Exit(1)
+			}
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.Path, "file", "f", "", "Path to blueprint file (required)")
+	cmd.Flags().StringVarP(&opts.Name, "name", "n", "", "Name of blueprint (default: filename, without extension)")
+	cmd.MarkFlagRequired("file")
+
+	return cmd
+}
+
+func applyBlueprintMain(cmd *cobra.Command, opts BlueprintCmdOpts) error {
+	api := api.FromContext(cmd.Context())
+	accountStore := config.AccountStoreFromContext(cmd.Context())
+
+	account, err := accountStore.ActiveAccount()
+	if err != nil {
+		logger.Error("Error: %v", err)
+		return err
+	}
+
+	if account.OrgID == "" {
+		logger.Error("Error: no organization selected. Run 'pangolin select org' first.")
+		return errors.New("no organization selected")
+	}
+
+	blueprintContents, err := os.ReadFile(opts.Path)
+	if err != nil {
+		logger.Error("Error: failed to read blueprint file: %v", err)
+		return err
+	}
+
+	_, err = api.ApplyBlueprint(account.OrgID, opts.Name, string(blueprintContents))
+	if err != nil {
+		logger.Error("Error: failed to apply blueprint: %v", err)
+		return err
+	}
+
+	logger.Info("Successfully applied blueprint!")
+
+	return nil
+}

cmd/auth/login/login.go

@@ -262,7 +262,8 @@ func loginMain(cmd *cobra.Command, opts *LoginCmdOpts) error {
 
 	var newAccount config.Account
 
-	// Re-use the current account entry in case
+	// Re-use the current account entry in case it exists
+	// This preserves OLM credentials across logout/login cycles
 	if account, exists := accountStore.Accounts[user.UserID]; exists {
 		newAccount = account
 	}
@@ -274,6 +275,14 @@ func loginMain(cmd *cobra.Command, opts *LoginCmdOpts) error {
 	newAccount.Host = hostname
 	newAccount.SessionToken = sessionToken
 
+	// Update account with username and name from user data
+	if user.Username != nil {
+		newAccount.Username = user.Username
+	}
+	if user.Name != nil {
+		newAccount.Name = user.Name
+	}
+
 	// Ensure new user has an organization selected
 	if newAccount.OrgID == "" {
 		orgID, err := utils.SelectOrgForm(apiClient, userID)
@@ -287,7 +296,7 @@ func loginMain(cmd *cobra.Command, opts *LoginCmdOpts) error {
 
 	// Ensure OLM credentials exist
 	if newAccount.OlmCredentials == nil {
-		newOlmCreds, err := apiClient.CreateOlm(userID, utils.GetDeviceName())
+		newOlmCreds, err := apiClient.CreateOlm(userID, getDeviceName())
 		if err != nil {
 			logger.Error("Failed to obtain olm credentials: %v", err)
 			return err
@@ -298,7 +307,7 @@ func loginMain(cmd *cobra.Command, opts *LoginCmdOpts) error {
 			Secret: newOlmCreds.Secret,
 		}
 	} else {
-		// logger.Info("Olm credentials already exist for this account, skipping generation")
+		logger.Info("Olm credentials already exist for this account, skipping generation")
 	}
 
 	accountStore.Accounts[user.UserID] = newAccount
@@ -311,13 +320,35 @@ func loginMain(cmd *cobra.Command, opts *LoginCmdOpts) error {
 		return err
 	}
 
-	// Print logged in message after all setup is complete
-	displayName := user.Email
-	if displayName == "" && user.Username != nil && *user.Username != "" {
-		displayName = *user.Username
+	// Fetch server info after successful authentication
+	apiServerInfo, err := apiClient.GetServerInfo()
+	if err != nil {
+		// Log warning but don't fail login if server info fetch fails
+		logger.Debug("Failed to fetch server info: %v", err)
+	} else if apiServerInfo != nil {
+		// Convert api.ServerInfo to config.ServerInfo
+		serverInfo := &config.ServerInfo{
+			Version:                  apiServerInfo.Version,
+			SupporterStatusValid:     apiServerInfo.SupporterStatusValid,
+			Build:                    apiServerInfo.Build,
+			EnterpriseLicenseValid:   apiServerInfo.EnterpriseLicenseValid,
+			EnterpriseLicenseType:    apiServerInfo.EnterpriseLicenseType,
+		}
+		// Update account with server info
+		account := accountStore.Accounts[user.UserID]
+		account.ServerInfo = serverInfo
+		accountStore.Accounts[user.UserID] = account
+		if err := accountStore.Save(); err != nil {
+			logger.Debug("Failed to save server info: %v", err)
+		}
 	}
-	if displayName != "" {
-		logger.Success("Logged in as %s", displayName)
+
+	// Print logged in message after all setup is complete
+	if user != nil {
+		displayName := utils.UserDisplayName(user)
+		if displayName != "" {
+			logger.Success("Logged in as %s", displayName)
+		}
 	}
 
 	return nil

cmd/auth/logout/logout.go

@@ -108,18 +108,20 @@ func logoutMain(cmd *cobra.Command) error {
 		return err
 	}
 
+	// Deactivate clears session token and org ID but keeps OLM credentials
 	if err := accountStore.Deactivate(accountStore.ActiveUserID); err != nil {
 		logger.Error("Failed to save account store: %v", err)
 		return err
 	}
 
-	if err := accountStore.Save(); err != nil {
-		logger.Error("Failed to save account store: %v", err)
-		return err
-	}
-
 	// Print logout message with account name
-	logger.Success("Logged out of Pangolin account %s", account.Email)
+	displayName := account.Email
+	if account.Name != nil && *account.Name != "" {
+		displayName = *account.Name
+	} else if account.Username != nil && *account.Username != "" {
+		displayName = *account.Username
+	}
+	logger.Success("Logged out of Pangolin account %s", displayName)
 
 	return nil
 }

cmd/auth/status/status.go

@@ -3,10 +3,12 @@ package status
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/fosrl/cli/internal/api"
 	"github.com/fosrl/cli/internal/config"
 	"github.com/fosrl/cli/internal/logger"
+	"github.com/fosrl/cli/internal/utils"
 	"github.com/spf13/cobra"
 )
 
@@ -36,14 +38,60 @@ func statusMain(cmd *cobra.Command) error {
 		return err
 	}
 
-	// User info exists in config, try to get user from API
+	// Check health before fetching user data
+	healthOk, healthErr := apiClient.CheckHealth()
+	isServerDown := healthErr != nil || !healthOk
+
+	if isServerDown {
+		logger.Warning("The server appears to be down.")
+		fmt.Println()
+		// Still show account info from stored data
+		logger.Info("Status: logged in (using cached account data)")
+		logger.Info("@ %s", account.Host)
+		fmt.Println()
+
+		// Display account information from stored data
+		displayName := utils.AccountDisplayName(account)
+		if displayName != "" {
+			logger.Info("User: %s", displayName)
+		}
+		if account.UserID != "" {
+			logger.Info("User ID: %s", account.UserID)
+		}
+
+		// Display organization information if available
+		if account.OrgID != "" {
+			logger.Info("Org ID: %s", account.OrgID)
+		}
+
+		return nil
+	}
+
+	// Health check passed, try to get user from API
 	user, err := apiClient.GetUser()
 	if err != nil {
-		// Unable to get user - consider logged out (previously logged in but now not)
-		logger.Info("Status: logged out: %v", err)
-		logger.Info("Your session has expired or is invalid")
-		logger.Info("Run 'pangolin login' to authenticate again")
-		return err
+		// Unable to get user - show error but still display account info
+		logger.Warning("Failed to fetch user data: %v", err)
+		fmt.Println()
+		logger.Info("Status: logged in (using cached account data)")
+		logger.Info("@ %s", account.Host)
+		fmt.Println()
+
+		// Display account information from stored data
+		displayName := utils.AccountDisplayName(account)
+		if displayName != "" {
+			logger.Info("User: %s", displayName)
+		}
+		if account.UserID != "" {
+			logger.Info("User ID: %s", account.UserID)
+		}
+
+		// Display organization information if available
+		if account.OrgID != "" {
+			logger.Info("Org ID: %s", account.OrgID)
+		}
+
+		return nil
 	}
 
 	// Successfully got user - logged in
@@ -53,12 +101,7 @@ func statusMain(cmd *cobra.Command) error {
 	fmt.Println()
 
 	// Display user information
-	displayName := user.Email
-	if user.Username != nil && *user.Username != "" {
-		displayName = *user.Username
-	} else if user.Name != nil && *user.Name != "" {
-		displayName = *user.Name
-	}
+	displayName := utils.UserDisplayName(user)
 	if displayName != "" {
 		logger.Info("User: %s", displayName)
 	}
@@ -67,7 +110,48 @@ func statusMain(cmd *cobra.Command) error {
 	}
 
 	// Display organization information
-	logger.Info("Org ID: %s", account.OrgID)
+	if account.OrgID != "" {
+		logger.Info("Org ID: %s", account.OrgID)
+	}
+
+	// Show watermark messages if server info is available
+	if account.ServerInfo != nil {
+		watermark := getWatermarkMessage(account.ServerInfo)
+		if watermark != "" {
+			fmt.Println()
+			logger.Info(watermark)
+		}
+	}
 
 	return nil
 }
+
+// getWatermarkMessage returns the appropriate watermark message based on server info
+func getWatermarkMessage(serverInfo *config.ServerInfo) string {
+	if serverInfo == nil {
+		return ""
+	}
+
+	build := strings.ToLower(serverInfo.Build)
+	licenseType := ""
+	if serverInfo.EnterpriseLicenseType != nil {
+		licenseType = strings.ToLower(*serverInfo.EnterpriseLicenseType)
+	}
+
+	// Enterprise + Personal License
+	if build == "enterprise" && licenseType == "personal" {
+		return "Licensed for personal use only."
+	}
+
+	// Enterprise + Unlicensed
+	if build == "enterprise" && !serverInfo.EnterpriseLicenseValid {
+		return "This server is unlicensed."
+	}
+
+	// OSS + No Supporter Key
+	if build == "oss" && !serverInfo.SupporterStatusValid {
+		return "Community Edition. Consider supporting."
+	}
+
+	return ""
+}

cmd/down/client/client.go

@@ -60,7 +60,7 @@ func clientDownMain(cmd *cobra.Command) error {
 	}
 
 	// Show log preview until process stops
-	completed, err := tui.NewLogPreview(tui.LogPreviewConfig{
+	completed, _, err := tui.NewLogPreview(tui.LogPreviewConfig{
 		LogFile: cfg.LogFile,
 		Header:  "Shutting down client...",
 		ExitCondition: func(client *olm.Client, status *olm.StatusResponse) (bool, bool) {

cmd/root.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/fosrl/cli/cmd/apply"
 	"github.com/fosrl/cli/cmd/auth"
 	"github.com/fosrl/cli/cmd/auth/login"
 	"github.com/fosrl/cli/cmd/auth/logout"
@@ -41,6 +42,7 @@ func RootCommand(initResources bool) (*cobra.Command, error) {
 	}
 
 	cmd.AddCommand(auth.AuthCommand())
+	cmd.AddCommand(apply.ApplyCommand())
 	cmd.AddCommand(selectcmd.SelectCmd())
 	cmd.AddCommand(up.UpCmd())
 	cmd.AddCommand(down.DownCmd())