@caretive/caret-cli 0.0.1

package/pkg/cli/auth/auth_subscription.go

@@ -0,0 +1,130 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/grpc-go/cline"
+)
+
+// AuthStatusListener manages subscription to auth status updates
+type AuthStatusListener struct {
+	stream    cline.AccountService_SubscribeToAuthStatusUpdateClient
+	updatesCh chan *cline.AuthState
+	errCh     chan error
+	ctx       context.Context
+	cancel    context.CancelFunc
+}
+
+// NewAuthStatusListener creates a new auth status listener
+func NewAuthStatusListener(parentCtx context.Context) (*AuthStatusListener, error) {
+	client, err := global.GetDefaultClient(parentCtx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get client: %w", err)
+	}
+
+	// Create cancellable context
+	ctx, cancel := context.WithCancel(parentCtx)
+
+	// Subscribe to auth status updates
+	stream, err := client.Account.SubscribeToAuthStatusUpdate(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		cancel()
+		return nil, fmt.Errorf("failed to subscribe to auth updates: %w", err)
+	}
+
+	return &AuthStatusListener{
+		stream:    stream,
+		updatesCh: make(chan *cline.AuthState, 10),
+		errCh:     make(chan error, 1),
+		ctx:       ctx,
+		cancel:    cancel,
+	}, nil
+}
+
+// Start begins listening to the auth status update stream
+func (l *AuthStatusListener) Start() error {
+	verboseLog("Starting auth status listener...")
+
+	go l.readStream()
+
+	return nil
+}
+
+// readStream reads from the gRPC stream and forwards messages to channels
+func (l *AuthStatusListener) readStream() {
+	defer close(l.updatesCh)
+	defer close(l.errCh)
+
+	for {
+		select {
+		case <-l.ctx.Done():
+			verboseLog("Auth listener context cancelled")
+			return
+		default:
+			state, err := l.stream.Recv()
+			if err != nil {
+				if err == io.EOF {
+					verboseLog("Auth status stream closed")
+					return
+				}
+				verboseLog("Error reading from auth status stream: %v", err)
+				select {
+				case l.errCh <- err:
+				case <-l.ctx.Done():
+				}
+				return
+			}
+
+			verboseLog("Received auth state update: user=%v", state.User != nil)
+
+			select {
+			case l.updatesCh <- state:
+			case <-l.ctx.Done():
+				return
+			}
+		}
+	}
+}
+
+// WaitForAuthentication blocks until authentication succeeds or timeout occurs
+func (l *AuthStatusListener) WaitForAuthentication(timeout time.Duration) error {
+	verboseLog("Waiting for authentication (timeout: %v)...", timeout)
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-timer.C:
+			return fmt.Errorf("authentication timeout after %v - please try again", timeout)
+
+		case <-l.ctx.Done():
+			return fmt.Errorf("authentication cancelled")
+
+		case err := <-l.errCh:
+			return fmt.Errorf("authentication stream error: %w", err)
+
+		case state := <-l.updatesCh:
+			if isAuthenticated(state) {
+				verboseLog("Authentication successful!")
+				return nil
+			}
+			verboseLog("Received auth update but not authenticated yet...")
+		}
+	}
+}
+
+// Stop closes the stream and cleans up resources
+func (l *AuthStatusListener) Stop() {
+	verboseLog("Stopping auth status listener...")
+	l.cancel()
+}
+
+// isAuthenticated checks if AuthState indicates successful authentication
+func isAuthenticated(state *cline.AuthState) bool {
+	return state != nil && state.User != nil
+}

package/pkg/cli/auth/byo_quick_setup.go

@@ -0,0 +1,247 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/cli/pkg/cli/task"
+	"github.com/cline/grpc-go/cline"
+)
+
+// Package-level variables for command-line flags
+var (
+	QuickProvider string // Provider ID (e.g., "openai", "anthropic")
+	QuickAPIKey   string // API key for the provider
+	QuickModelID  string // Model ID to configure
+	QuickBaseURL  string // Base URL (optional, for openai compatible only)
+)
+
+// QuickSetupFromFlags performs quick setup using command-line flags
+// Returns error if validation fails or configuration cannot be applied
+func QuickSetupFromFlags(ctx context.Context, provider, apiKey, modelID, baseURL string) error {
+	// Validate all input parameters
+	providerEnum, err := validateQuickSetupInputs(provider, apiKey, modelID, baseURL)
+	if err != nil {
+		return err
+	}
+
+	// Create task manager for state operations
+	manager, err := createTaskManager(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to create task manager: %w", err)
+	}
+
+	// Validate and fetch model information if needed
+	finalModelID, modelInfo, err := validateAndFetchModel(ctx, manager, providerEnum, modelID, apiKey)
+	if err != nil {
+		return fmt.Errorf("model validation failed: %w", err)
+	}
+
+	// For Ollama, baseURL is stored in the API key field
+	finalAPIKey := apiKey
+	finalBaseURL := baseURL
+	if providerEnum == cline.ApiProvider_OLLAMA {
+		if baseURL != "" {
+			finalAPIKey = baseURL
+			finalBaseURL = ""
+		} else if apiKey != "" {
+			// User provided API key for Ollama - treat it as baseURL
+			finalAPIKey = apiKey
+			finalBaseURL = ""
+		} else {
+			// Use default Ollama baseURL
+			finalAPIKey = "http://localhost:11434"
+			finalBaseURL = ""
+		}
+	}
+
+	// Configure the provider using existing AddProviderPartial function
+	if err := AddProviderPartial(ctx, manager, providerEnum, finalModelID, finalAPIKey, finalBaseURL, modelInfo); err != nil {
+		return fmt.Errorf("failed to configure provider: %w", err)
+	}
+
+	// Set the provider as active for both Plan and Act modes
+	if err := UpdateProviderPartial(ctx, manager, providerEnum, ProviderUpdatesPartial{}, true); err != nil {
+		return fmt.Errorf("failed to set provider as active: %w", err)
+	}
+
+	// Mark welcome view as completed
+	if err := markWelcomeViewCompleted(ctx, manager); err != nil {
+		// Non-fatal error, just log it
+		if global.Config.Verbose {
+			fmt.Printf("[DEBUG] Warning: failed to mark welcome view as completed: %v\n", err)
+		}
+	}
+
+	// Flush pending state changes to disk immediately
+	// This ensures all configuration changes are persisted before the instance terminates
+	if _, err := manager.GetClient().State.FlushPendingState(ctx, &cline.EmptyRequest{}); err != nil {
+		return fmt.Errorf("failed to flush pending state: %w", err)
+	}
+
+	// Success message
+	fmt.Printf("\n✓ Successfully configured %s provider\n", GetProviderDisplayName(providerEnum))
+	fmt.Printf("  Model: %s\n", finalModelID)
+	if providerEnum == cline.ApiProvider_OLLAMA {
+		fmt.Printf("  Base URL: %s\n", finalAPIKey)
+	} else {
+		fmt.Println("  API Key: Configured")
+	}
+	if finalBaseURL != "" {
+		fmt.Printf("  Custom Base URL: %s\n", finalBaseURL)
+	}
+	fmt.Println("\nYou can now use Cline with this provider.")
+	fmt.Println("Run 'cline start' to begin a new task.")
+
+	return nil
+}
+
+// validateQuickSetupInputs validates all input parameters for quick setup
+// Returns the validated provider enum or an error if validation fails
+func validateQuickSetupInputs(provider, apiKey, modelID, baseURL string) (cline.ApiProvider, error) {
+	// Validate required parameters
+	if provider == "" {
+		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("provider is required. Use --provider or -p flag")
+	}
+
+	if strings.TrimSpace(apiKey) == "" && provider != "ollama" {
+		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("API key is required for %s provider. Use --apikey or -k flag", provider)
+	}
+
+	if strings.TrimSpace(modelID) == "" {
+		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("model ID is required. Use --modelid or -m flag")
+	}
+
+	// Validate and map provider string to enum
+	providerEnum, err := validateQuickSetupProvider(provider)
+	if err != nil {
+		return cline.ApiProvider_ANTHROPIC, err
+	}
+
+	// Validate that baseURL is only provided for OpenAI-compatible providers
+	if err := validateBaseURL(baseURL, providerEnum); err != nil {
+		return cline.ApiProvider_ANTHROPIC, err
+	}
+
+	return providerEnum, nil
+}
+
+// validateBaseURL checks if the user's input includes a baseURL for a provider other than OpenAI (compatible)
+// Returns error if baseURL is provided for unsupported providers
+func validateBaseURL(baseURL string, providerEnum cline.ApiProvider) error {
+	if providerEnum != cline.ApiProvider_OPENAI {
+		if baseURL != "" {
+			return fmt.Errorf("base URL is only supported for OpenAI and OpenAI-compatible providers")
+		}
+	}
+	return nil
+}
+
+
+// validateQuickSetupProvider validates the provider ID and returns the enum value
+// Returns error if provider is invalid or not supported for quick setup
+func validateQuickSetupProvider(providerID string) (cline.ApiProvider, error) {
+	// Normalize provider ID (trim whitespace, lowercase)
+	normalizedID := strings.TrimSpace(strings.ToLower(providerID))
+
+	// Explicitly block Bedrock
+	if normalizedID == "bedrock" {
+		return cline.ApiProvider_BEDROCK, fmt.Errorf("bedrock provider is not supported for quick setup due to complex authentication requirements. Please use interactive setup: cline auth")
+	}
+
+	// Map provider string to enum using existing function
+	provider, ok := mapProviderStringToEnum(normalizedID)
+	if !ok {
+		// Provider not found - provide helpful error message
+		supportedProviders := []string{
+			"openai-native", "openai", "anthropic", "gemini",
+			"openrouter", "xai", "cerebras", "ollama",
+		}
+		return cline.ApiProvider_ANTHROPIC, fmt.Errorf(
+			"invalid provider '%s'. Supported providers: %s",
+			providerID,
+			strings.Join(supportedProviders, ", "),
+		)
+	}
+
+	// Validate against supported quick setup providers
+	supportedProviders := map[cline.ApiProvider]bool{
+		cline.ApiProvider_OPENAI_NATIVE: true,
+		cline.ApiProvider_OPENAI:        true,
+		cline.ApiProvider_ANTHROPIC:     true,
+		cline.ApiProvider_GEMINI:        true,
+		cline.ApiProvider_OPENROUTER:    true,
+		cline.ApiProvider_XAI:           true,
+		cline.ApiProvider_CEREBRAS:      true,
+		cline.ApiProvider_OLLAMA:        true,
+		cline.ApiProvider_NOUSRESEARCH:  true,
+	}
+
+	if !supportedProviders[provider] {
+		return provider, fmt.Errorf(
+			"provider '%s' is not supported for quick setup. Please use interactive setup: cline auth",
+			providerID,
+		)
+	}
+
+	return provider, nil
+}
+
+// validateAndFetchModel validates the model ID or fetches from provider if needed
+// Returns the final model ID and optional model info
+// For providers with static models, validates against the list
+// For providers with dynamic models, fetches the list if possible
+func validateAndFetchModel(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID, apiKey string) (string, interface{}, error) {
+	// Normalize model ID
+	modelID = strings.TrimSpace(modelID)
+	if modelID == "" {
+		return "", nil, fmt.Errorf("model ID cannot be empty")
+	}
+
+	// For most providers, we trust the user's input since we can't easily validate without making API calls
+	// The actual validation will happen when the model is used
+	switch provider {
+	case cline.ApiProvider_OPENROUTER:
+		// OpenRouter supports model info fetching, but it requires an API call
+		// For quick setup, we'll trust the user's input and return nil for model info
+		// The actual model info will be fetched when needed
+		if global.Config.Verbose {
+			fmt.Printf("[DEBUG] OpenRouter model ID: %s (will be validated on first use)\n", modelID)
+		}
+		return modelID, nil, nil
+
+	case cline.ApiProvider_OLLAMA:
+		// Ollama models can be validated by fetching the list, but this requires the server to be running
+		// For quick setup, we'll trust the user's input
+		if global.Config.Verbose {
+			fmt.Printf("[DEBUG] Ollama model ID: %s (will be validated when server is accessible)\n", modelID)
+		}
+		return modelID, nil, nil
+
+	default:
+		// For other providers (Anthropic, OpenAI, Gemini, XAI, Cerebras), trust user input
+		// Model validation will occur when the model is actually used
+		if global.Config.Verbose {
+			fmt.Printf("[DEBUG] %s model ID: %s (will be validated on first use)\n", GetProviderDisplayName(provider), modelID)
+		}
+		return modelID, nil, nil
+	}
+}
+
+// markWelcomeViewCompleted marks the welcome view as completed in the state
+// This prevents the welcome view from showing up after quick setup
+func markWelcomeViewCompleted(ctx context.Context, manager *task.Manager) error {
+	// Use the State service to update the welcome view flag
+	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
+	if err != nil {
+		return fmt.Errorf("failed to mark welcome view as completed: %w", err)
+	}
+
+	if global.Config.Verbose {
+		fmt.Println("[DEBUG] Marked welcome view as completed")
+	}
+
+	return nil
+}

package/pkg/cli/auth/models_cline.go

@@ -0,0 +1,141 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/cli/pkg/cli/task"
+	"github.com/cline/grpc-go/cline"
+)
+
+// DefaultClineModelID is the default model ID for Cline provider.
+// Cline uses OpenRouter-compatible model IDs.
+const DefaultClineModelID = "anthropic/claude-sonnet-4.5"
+
+// FetchClineModels fetches available Cline models from Cline Core.
+// Note: Cline provider uses OpenRouter-compatible API and model format.
+// The models are fetched using the same method as OpenRouter.
+func FetchClineModels(ctx context.Context, manager *task.Manager) (map[string]*cline.OpenRouterModelInfo, error) {
+	if global.Config.Verbose {
+		fmt.Println("Fetching Cline models (using OpenRouter-compatible API)")
+	}
+
+	// Cline uses OpenRouter model fetching
+	models, err := FetchOpenRouterModels(ctx, manager)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch Cline models: %w", err)
+	}
+
+	return models, nil
+}
+
+// GetClineModelInfo retrieves information for a specific Cline model.
+func GetClineModelInfo(modelID string, models map[string]*cline.OpenRouterModelInfo) (*cline.OpenRouterModelInfo, error) {
+	modelInfo, exists := models[modelID]
+	if !exists {
+		return nil, fmt.Errorf("model %s not found", modelID)
+	}
+	return modelInfo, nil
+}
+
+// SetDefaultClineModel configures the default Cline model after authentication.
+// This is called automatically after successful Cline sign-in.
+func SetDefaultClineModel(ctx context.Context, manager *task.Manager) error {
+
+	// Fetch available models
+	models, err := FetchClineModels(ctx, manager)
+	if err != nil {
+		// If we can't fetch models, we'll use the default without model info
+		fmt.Printf("Warning: Could not fetch Cline models: %v\n", err)
+		fmt.Printf("Using default model: %s\n", DefaultClineModelID)
+		return applyDefaultClineModel(ctx, manager, nil)
+	}
+
+	// Check if default model is available
+	modelInfo, err := GetClineModelInfo(DefaultClineModelID, models)
+	if err != nil {
+		fmt.Printf("Warning: Default model not found: %v\n", err)
+		// Try to use any available model
+		for modelID := range models {
+			fmt.Printf("Using available model: %s\n", modelID)
+			return applyClineModelConfiguration(ctx, manager, modelID, models[modelID])
+		}
+		return fmt.Errorf("no usable Cline models found")
+	}
+
+	if err := applyClineModelConfiguration(ctx, manager, DefaultClineModelID, modelInfo); err != nil {
+		return err
+	}
+
+	if err := setWelcomeViewCompletedWithManager(ctx, manager); err != nil {
+		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
+	}
+
+	return nil
+}
+
+// SelectClineModel presents a menu to select a Cline model and applies the configuration.
+func SelectClineModel(ctx context.Context, manager *task.Manager) error {
+
+	// Fetch models (uses OpenRouter-compatible format)
+	models, err := FetchClineModels(ctx, manager)
+	if err != nil {
+		return fmt.Errorf("failed to fetch Cline models: %w", err)
+	}
+
+	// Convert to interface map for generic utilities
+	modelMap := ConvertOpenRouterModelsToInterface(models)
+
+	// Get model IDs as a sorted list
+	modelIDs := ConvertModelsMapToSlice(modelMap)
+
+	// Display selection menu
+	selectedModelID, err := DisplayModelSelectionMenu(modelIDs, "Cline")
+	if err != nil {
+		return fmt.Errorf("model selection failed: %w", err)
+	}
+
+	// Get the selected model info
+	modelInfo := models[selectedModelID]
+
+	// Apply the configuration
+	if err := applyClineModelConfiguration(ctx, manager, selectedModelID, modelInfo); err != nil {
+		return err
+	}
+
+	fmt.Println()
+
+	// Return to main auth menu after model selection
+	return HandleAuthMenuNoArgs(ctx)
+}
+
+// applyClineModelConfiguration applies a Cline model configuration to both Act and Plan modes using UpdateProviderPartial.
+// Cline uses OpenRouter-compatible model format.
+func applyClineModelConfiguration(ctx context.Context, manager *task.Manager, modelID string, modelInfo *cline.OpenRouterModelInfo) error {
+	provider := cline.ApiProvider_CLINE
+
+	updates := ProviderUpdatesPartial{
+		ModelID:   &modelID,
+		ModelInfo: modelInfo,
+	}
+
+	return UpdateProviderPartial(ctx, manager, provider, updates, true)
+}
+
+func applyDefaultClineModel(ctx context.Context, manager *task.Manager, modelInfo *cline.OpenRouterModelInfo) error {
+	if err := applyClineModelConfiguration(ctx, manager, DefaultClineModelID, modelInfo); err != nil {
+		return err
+	}
+
+	if err := setWelcomeViewCompletedWithManager(ctx, manager); err != nil {
+		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
+	}
+
+	return nil
+}
+
+func setWelcomeViewCompletedWithManager(ctx context.Context, manager *task.Manager) error {
+	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
+	return err
+}

package/pkg/cli/auth/models_list_fetch.go

@@ -0,0 +1,156 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sort"
+
+	"github.com/charmbracelet/huh"
+	"github.com/cline/cli/pkg/cli/task"
+	"github.com/cline/grpc-go/cline"
+	"golang.org/x/term"
+)
+
+// FetchOpenRouterModels fetches available OpenRouter models from Cline Core
+func FetchOpenRouterModels(ctx context.Context, manager *task.Manager) (map[string]*cline.OpenRouterModelInfo, error) {
+	resp, err := manager.GetClient().Models.RefreshOpenRouterModelsRpc(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch OpenRouter models: %w", err)
+	}
+	return resp.Models, nil
+}
+
+// FetchOcaModels fetches available Oca models from Cline Core
+func FetchOcaModels(ctx context.Context, manager *task.Manager) (map[string]*cline.OcaModelInfo, error) {
+	resp, err := manager.GetClient().Models.RefreshOcaModels(ctx, &cline.StringRequest{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch Oca models: %w", err)
+	}
+	return resp.Models, nil
+}
+
+// ConvertOpenRouterModelsToInterface converts OpenRouter model map to generic interface map.
+// This allows OpenRouter and Cline models to be used with the generic fetching utilities.
+func ConvertOpenRouterModelsToInterface(models map[string]*cline.OpenRouterModelInfo) map[string]interface{} {
+	result := make(map[string]interface{}, len(models))
+	for k, v := range models {
+		result[k] = v
+	}
+	return result
+}
+
+
+// FetchOpenAiModels fetches available OpenAI models from Cline Core
+// Takes the API key and returns a list of model IDs
+func FetchOpenAiModels(ctx context.Context, manager *task.Manager, baseURL, apiKey string) ([]string, error) {
+	req := &cline.OpenAiModelsRequest{
+		BaseUrl: baseURL,
+		ApiKey:  apiKey,
+	}
+
+	resp, err := manager.GetClient().Models.RefreshOpenAiModels(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch OpenAI models: %w", err)
+	}
+	return resp.Values, nil
+}
+
+// FetchOllamaModels fetches available Ollama models from Cline Core
+// Takes the base URL (empty string for default) and returns a list of model IDs
+func FetchOllamaModels(ctx context.Context, manager *task.Manager, baseURL string) ([]string, error) {
+	req := &cline.StringRequest{
+		Value: baseURL,
+	}
+
+	resp, err := manager.GetClient().Models.GetOllamaModels(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch Ollama models: %w", err)
+	}
+	return resp.Values, nil
+}
+
+// DisplayModelSelectionMenu shows an interactive menu for selecting a model from a list.
+// Models are displayed alphabetically. Uses model ID as the option value to avoid
+// index-based bugs when list order changes.
+// Returns the selected model ID.
+func DisplayModelSelectionMenu(models []string, providerName string) (string, error) {
+	if len(models) == 0 {
+		return "", fmt.Errorf("no models available for selection")
+	}
+
+	// Use model ID as the value (not index) to avoid positional coupling bugs
+	var selectedModel string
+	options := make([]huh.Option[string], len(models))
+	for i, model := range models {
+		options[i] = huh.NewOption(model, model)
+	}
+
+	title := fmt.Sprintf("Select a %s model", providerName)
+
+	form := huh.NewForm(
+		huh.NewGroup(
+			huh.NewSelect[string]().
+				Title(title).
+				Options(options...).
+				Height(calculateSelectHeight()).
+				Filtering(true).
+				Value(&selectedModel),
+		),
+	)
+
+	if err := form.Run(); err != nil {
+		return "", fmt.Errorf("failed to select model: %w", err)
+	}
+
+	return selectedModel, nil
+}
+
+// ConvertModelsMapToSlice converts a map of models to a sorted slice of model IDs.
+// This is useful for displaying models in a consistent order in UI components.
+func ConvertModelsMapToSlice(models map[string]interface{}) []string {
+	result := make([]string, 0, len(models))
+	for modelID := range models {
+		result = append(result, modelID)
+	}
+
+	// Sort alphabetically for consistent display
+	sort.Strings(result)
+
+	return result
+}
+
+// ConvertOcaModelsToInterface converts Oca model map to generic interface map.
+// This allows Oca and Cline models to be used with the generic fetching utilities.
+func ConvertOcaModelsToInterface(models map[string]*cline.OcaModelInfo) map[string]interface{} {
+	result := make(map[string]interface{}, len(models))
+	for k, v := range models {
+		result[k] = v
+	}
+	return result
+}
+
+// getTerminalHeight returns the terminal height (rows)
+func getTerminalHeight() int {
+	_, height, err := term.GetSize(int(os.Stdout.Fd()))
+	if err != nil || height <= 0 {
+		return 25 // safe fallback for non-TTY or errors
+	}
+	return height
+}
+
+// calculateSelectHeight computes appropriate height for Select component
+// Reserves space for title, search UI, and margins
+func calculateSelectHeight() int {
+	height := getTerminalHeight()
+	// Reserve ~10 rows for UI chrome (title, search, margins)
+	visibleRows := height - 10
+	// Clamp between 8 (minimum usable) and 25 (maximum before unwieldy)
+	if visibleRows < 8 {
+		return 8
+	}
+	if visibleRows > 25 {
+		return 25
+	}
+	return visibleRows
+}