Show plan name and config path in header

cmd/root.go

@@ -128,8 +128,30 @@ func startEmulator(ctx context.Context, rt runtime.Runtime, cfg *env.Env, tel *t
 		PersistDisable: config.DisableUpdatePrompt,
 	}
 
+	configPath, err := config.FriendlyConfigPath()
+	if err != nil {
+		logger.Info("could not resolve friendly config path: %v", err)
+	}
+
 	if isInteractiveMode(cfg) {
-		return ui.Run(ctx, rt, version.Version(), opts, notifyOpts)
+		labelCh := make(chan string, 1)
+		go func() {
+			label, ok := container.ResolveEmulatorLabel(ctx, opts.PlatformClient, appConfig.Containers, cfg.AuthToken, logger)
+			if ok {
+				config.CachePlanLabel(label)
+			}
+			labelCh <- label
+		}()
+
+		return ui.Run(ctx, ui.RunOptions{
+			Runtime:       rt,
+			Version:       version.Version(),
+			StartOptions:  opts,
+			NotifyOptions: notifyOpts,
+			ConfigPath:    configPath,
+			EmulatorLabel: config.CachedPlanLabel(),
+			LabelCh:       labelCh,
+		})
 	}
 
 	sink := output.NewPlainSink(os.Stdout)

internal/api/client.go

@@ -21,7 +21,7 @@ type PlatformAPI interface {
 	CheckAuthRequestConfirmed(ctx context.Context, id, exchangeToken string) (bool, error)
 	ExchangeAuthRequest(ctx context.Context, id, exchangeToken string) (string, error)
 	GetLicenseToken(ctx context.Context, bearerToken string) (string, error)
-	GetLicense(ctx context.Context, req *LicenseRequest) error
+	GetLicense(ctx context.Context, req *LicenseRequest) (*LicenseResponse, error)
 	GetLatestCatalogVersion(ctx context.Context, emulatorType string) (string, error)
 }
 
@@ -65,6 +65,34 @@ type MachineInfo struct {
 	PlatformRelease string `json:"platform_release,omitempty"`
 }
 
+type LicenseResponse struct {
+	LicenseType string `json:"license_type"`
+}
+
+var planDisplayNames = map[string]string{
+	"hobby":      "Hobby",
+	"pro":        "Pro",
+	"team":       "Teams",
+	"enterprise": "Enterprise",
+	"trial":      "Trial",
+	"freemium":   "Community",
+	"base":       "Starter",
+	"ultimate":   "Ultimate",
+	"student":    "Student",
+}
+
+// PlanDisplayName returns a human-readable plan name for the license type.
+// Returns an empty string for a nil receiver or unknown types.
+func (r *LicenseResponse) PlanDisplayName() string {
+	if r == nil {
+		return ""
+	}
+	if name, ok := planDisplayNames[r.LicenseType]; ok {
+		return name
+	}
+	return r.LicenseType
+}
+
 // LicenseError is returned when license validation fails.
 // Message is user-friendly; Detail contains the raw server response for debugging.
 type LicenseError struct {
@@ -222,56 +250,63 @@ func (c *PlatformClient) GetLicenseToken(ctx context.Context, bearerToken string
 	return tokenResp.Token, nil
 }
 
-func (c *PlatformClient) GetLicense(ctx context.Context, licReq *LicenseRequest) error {
+func (c *PlatformClient) GetLicense(ctx context.Context, licReq *LicenseRequest) (*LicenseResponse, error) {
 	body, err := json.Marshal(licReq)
 	if err != nil {
-		return fmt.Errorf("failed to marshal request: %w", err)
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
 	}
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/v1/license/request", bytes.NewReader(body))
 	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to request license: %w", err)
+		return nil, fmt.Errorf("failed to request license: %w", err)
 	}
 
 	statusCode := resp.StatusCode
-	var detail string
-	if statusCode != http.StatusOK {
-		respBody, err := io.ReadAll(io.LimitReader(resp.Body, 1024))
-		if err != nil {
-			detail = fmt.Sprintf("failed to read response body: %v", err)
-		} else {
-			detail = string(bytes.TrimSpace(respBody))
+
+	if statusCode == http.StatusOK {
+		var licResp LicenseResponse
+		decErr := json.NewDecoder(resp.Body).Decode(&licResp)
+		if err := resp.Body.Close(); err != nil {
+			c.logger.Error("failed to close response body: %v", err)
 		}
+		if decErr != nil {
+			return nil, fmt.Errorf("failed to decode license response: %w", decErr)
+		}
+		return &licResp, nil
+	}
+
+	var detail string
+	respBody, err := io.ReadAll(io.LimitReader(resp.Body, 1024))
+	if err != nil {
+		detail = fmt.Sprintf("failed to read response body: %v", err)
+	} else {
+		detail = string(bytes.TrimSpace(respBody))
 	}
 	if err := resp.Body.Close(); err != nil {
 		c.logger.Error("failed to close response body: %v", err)
 	}
 
-	if statusCode == http.StatusOK {
-		return nil
-	}
-
 	switch statusCode {
 	case http.StatusBadRequest:
-		return &LicenseError{
+		return nil, &LicenseError{
 			Status:  statusCode,
 			Message: "invalid token format, missing license assignment, or missing subscription",
 			Detail:  detail,
 		}
 	case http.StatusForbidden:
-		return &LicenseError{
+		return nil, &LicenseError{
 			Status:  statusCode,
 			Message: "invalid, inactive, or expired authentication token or subscription",
 			Detail:  detail,
 		}
 	default:
-		return &LicenseError{
+		return nil, &LicenseError{
 			Status:  statusCode,
 			Message: fmt.Sprintf("unexpected status %d", statusCode),
 			Detail:  detail,

internal/api/license_test.go

@@ -0,0 +1,37 @@
+package api
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPlanDisplayName(t *testing.T) {
+	tests := []struct {
+		licenseType string
+		want        string
+	}{
+		{"hobby", "Hobby"},
+		{"pro", "Pro"},
+		{"team", "Teams"},
+		{"enterprise", "Enterprise"},
+		{"trial", "Trial"},
+		{"freemium", "Community"},
+		{"base", "Starter"},
+		{"ultimate", "Ultimate"},
+		{"student", "Student"},
+		{"unknown_type", "unknown_type"},
+		{"", ""},
+	}
+	for _, tc := range tests {
+		t.Run(tc.licenseType, func(t *testing.T) {
+			resp := &LicenseResponse{LicenseType: tc.licenseType}
+			assert.Equal(t, tc.want, resp.PlanDisplayName())
+		})
+	}
+}
+
+func TestPlanDisplayNameNilResponse(t *testing.T) {
+	var resp *LicenseResponse
+	assert.Equal(t, "", resp.PlanDisplayName())
+}

internal/config/paths.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 const (
@@ -48,6 +49,48 @@ func ConfigFilePath() (string, error) {
 	return absCreationPath, nil
 }
 
+// FriendlyConfigPath returns a human-readable config path: relative for
+// project-local configs, ~-prefixed for paths under $HOME, absolute otherwise.
+func FriendlyConfigPath() (string, error) {
+	absPath, err := ConfigFilePath()
+	if err != nil {
+		return "", err
+	}
+
+	resolved, err := filepath.EvalSymlinks(absPath)
+	if err != nil {
+		resolved = absPath
+	}
+
+	cwd, err := os.Getwd()
+	if err == nil {
+		if rel, relErr := filepath.Rel(cwd, resolved); relErr == nil && isInside(rel) {
+			return rel, nil
+		}
+	}
+
+	if home, err := os.UserHomeDir(); err == nil {
+		resolvedHome, evalErr := filepath.EvalSymlinks(home)
+		if evalErr != nil {
+			resolvedHome = home
+		}
+		if rel, relErr := filepath.Rel(resolvedHome, resolved); relErr == nil && isInside(rel) {
+			return filepath.Join("~", rel), nil
+		}
+	}
+
+	return absPath, nil
+}
+
+// isInside reports whether a relative path produced by filepath.Rel stays
+// inside the base directory (i.e. does not climb out via "..").
+func isInside(rel string) bool {
+	if rel == ".." {
+		return false
+	}
+	return !strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}
+
 func ConfigDir() (string, error) {
 	configPath, err := ConfigFilePath()
 	if err != nil {

internal/config/paths_test.go

@@ -0,0 +1,63 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFriendlyConfigPathRelativeForProjectLocal(t *testing.T) {
+	// Cannot run in parallel: mutates process-wide cwd and viper state.
+
+	tmpDir := t.TempDir()
+	dir, err := filepath.EvalSymlinks(tmpDir)
+	require.NoError(t, err)
+	configDir := filepath.Join(dir, ".lstk")
+	require.NoError(t, os.MkdirAll(configDir, 0755))
+
+	configFile := filepath.Join(configDir, "config.toml")
+	require.NoError(t, os.WriteFile(configFile, []byte("[aws]\n"), 0644))
+
+	origDir, err := os.Getwd()
+	require.NoError(t, err)
+
+	require.NoError(t, os.Chdir(dir))
+	t.Cleanup(func() { _ = os.Chdir(origDir) })
+
+	viper.Reset()
+	t.Cleanup(viper.Reset)
+	viper.SetConfigFile(configFile)
+	require.NoError(t, viper.ReadInConfig())
+
+	friendly, err := FriendlyConfigPath()
+	require.NoError(t, err)
+	require.Equal(t, filepath.Join(".lstk", "config.toml"), friendly)
+}
+
+func TestFriendlyConfigPathTildeForHomeDir(t *testing.T) {
+	// Cannot run in parallel: mutates process-wide viper state and HOME env.
+
+	fakeHome := t.TempDir()
+	resolvedHome, err := filepath.EvalSymlinks(fakeHome)
+	require.NoError(t, err)
+
+	configDir := filepath.Join(resolvedHome, ".config", "lstk")
+	require.NoError(t, os.MkdirAll(configDir, 0755))
+
+	configFile := filepath.Join(configDir, "config.toml")
+	require.NoError(t, os.WriteFile(configFile, []byte("[aws]\n"), 0644))
+
+	t.Setenv("HOME", resolvedHome)
+
+	viper.Reset()
+	t.Cleanup(viper.Reset)
+	viper.SetConfigFile(configFile)
+	require.NoError(t, viper.ReadInConfig())
+
+	friendly, err := FriendlyConfigPath()
+	require.NoError(t, err)
+	require.Equal(t, filepath.Join("~", ".config", "lstk", "config.toml"), friendly)
+}

internal/config/plan_cache.go

@@ -0,0 +1,29 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const planCacheFile = "plan_label"
+
+func CachedPlanLabel() string {
+	dir, err := ConfigDir()
+	if err != nil {
+		return ""
+	}
+	data, err := os.ReadFile(filepath.Join(dir, planCacheFile))
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+func CachePlanLabel(label string) {
+	dir, err := ConfigDir()
+	if err != nil {
+		return
+	}
+	_ = os.WriteFile(filepath.Join(dir, planCacheFile), []byte(label+"\n"), 0600)
+}