@caretive/caret-cli 0.0.1

package/pkg/cli/clerror/cline_error.go

@@ -0,0 +1,187 @@
+package clerror
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// ClineErrorType represents the category of error
+type ClineErrorType string
+
+const (
+	ErrorTypeAuth      ClineErrorType = "auth"
+	ErrorTypeNetwork   ClineErrorType = "network"
+	ErrorTypeRateLimit ClineErrorType = "rateLimit"
+	ErrorTypeBalance   ClineErrorType = "balance"
+	ErrorTypeUnknown   ClineErrorType = "unknown"
+)
+
+// ClineError represents a parsed error from Cline API
+type ClineError struct {
+	Message    string                 `json:"message"`
+	Status     int                    `json:"status"`
+	RequestID  string                 `json:"request_id"`
+	Code       interface{}            `json:"code"` // Can be string or int
+	ModelID    string                 `json:"modelId"`
+	ProviderID string                 `json:"providerId"`
+	Details    map[string]interface{} `json:"details"`
+}
+
+// GetCodeString returns the code as a string regardless of its type
+func (e *ClineError) GetCodeString() string {
+	if e == nil || e.Code == nil {
+		return ""
+	}
+	switch v := e.Code.(type) {
+	case string:
+		return v
+	case float64:
+		return fmt.Sprintf("%.0f", v)
+	case int:
+		return fmt.Sprintf("%d", v)
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
+// Rate limit patterns from webview
+var rateLimitPatterns = []string{
+	"status code 429",
+	"rate limit",
+	"too many requests",
+	"quota exceeded",
+	"resource exhausted",
+}
+
+// ParseClineError parses a JSON error string into a ClineError
+func ParseClineError(errorJSON string) (*ClineError, error) {
+	if errorJSON == "" {
+		return nil, nil
+	}
+
+	var err ClineError
+	if parseErr := json.Unmarshal([]byte(errorJSON), &err); parseErr != nil {
+		// If JSON parsing fails, create a simple error with the message
+		return &ClineError{
+			Message: errorJSON,
+		}, nil
+	}
+
+	return &err, nil
+}
+
+// GetErrorType determines the type of error based on code, status, and message
+func (e *ClineError) GetErrorType() ClineErrorType {
+	if e == nil {
+		return ErrorTypeUnknown
+	}
+
+	// Check balance error first (most specific)
+	codeStr := e.GetCodeString()
+	if codeStr == "insufficient_credits" {
+		return ErrorTypeBalance
+	}
+
+	// Check auth errors
+	if codeStr == "ERR_BAD_REQUEST" || e.Status == 401 {
+		return ErrorTypeAuth
+	}
+
+	// Check for auth message
+	if strings.Contains(e.Message, "Authentication required") ||
+		strings.Contains(e.Message, "Invalid API key") ||
+		strings.Contains(e.Message, "Unauthorized") {
+		return ErrorTypeAuth
+	}
+
+	// Check rate limit patterns
+	messageLower := strings.ToLower(e.Message)
+	for _, pattern := range rateLimitPatterns {
+		if strings.Contains(messageLower, pattern) {
+			return ErrorTypeRateLimit
+		}
+	}
+
+	return ErrorTypeUnknown
+}
+
+// IsBalanceError returns true if this is a balance/credits error
+func (e *ClineError) IsBalanceError() bool {
+	return e.GetErrorType() == ErrorTypeBalance
+}
+
+// IsAuthError returns true if this is an authentication error
+func (e *ClineError) IsAuthError() bool {
+	return e.GetErrorType() == ErrorTypeAuth
+}
+
+// IsRateLimitError returns true if this is a rate limit error
+func (e *ClineError) IsRateLimitError() bool {
+	return e.GetErrorType() == ErrorTypeRateLimit
+}
+
+// GetCurrentBalance returns the current balance if available
+func (e *ClineError) GetCurrentBalance() *float64 {
+	if e == nil || e.Details == nil {
+		return nil
+	}
+
+	if balance, ok := e.Details["current_balance"].(float64); ok {
+		return &balance
+	}
+
+	return nil
+}
+
+// GetBuyCreditsURL returns the URL to buy credits if available
+func (e *ClineError) GetBuyCreditsURL() string {
+	if e == nil || e.Details == nil {
+		return ""
+	}
+
+	if url, ok := e.Details["buy_credits_url"].(string); ok {
+		return url
+	}
+
+	return ""
+}
+
+// GetTotalSpent returns the total spent amount if available
+func (e *ClineError) GetTotalSpent() *float64 {
+	if e == nil || e.Details == nil {
+		return nil
+	}
+
+	if spent, ok := e.Details["total_spent"].(float64); ok {
+		return &spent
+	}
+
+	return nil
+}
+
+// GetTotalPromotions returns the total promotions amount if available
+func (e *ClineError) GetTotalPromotions() *float64 {
+	if e == nil || e.Details == nil {
+		return nil
+	}
+
+	if promos, ok := e.Details["total_promotions"].(float64); ok {
+		return &promos
+	}
+
+	return nil
+}
+
+// GetDetailMessage returns the detail message from error.details if available
+func (e *ClineError) GetDetailMessage() string {
+	if e == nil || e.Details == nil {
+		return ""
+	}
+
+	if msg, ok := e.Details["message"].(string); ok {
+		return msg
+	}
+
+	return ""
+}

package/pkg/cli/config/manager.go

@@ -0,0 +1,208 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/grpc-go/client"
+	"github.com/cline/grpc-go/cline"
+)
+
+type Manager struct {
+	client        *client.ClineClient
+	clientAddress string
+}
+
+func NewManager(ctx context.Context, address string) (*Manager, error) {
+	var c *client.ClineClient
+	var err error
+
+	if address != "" {
+		c, err = global.GetClientForAddress(ctx, address)
+	} else {
+		c, err = global.GetDefaultClient(ctx)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to get client: %w", err)
+	}
+
+	// Get the actual address being used
+	clientAddress := address
+	if address == "" && global.Clients != nil {
+		clientAddress = global.Clients.GetRegistry().GetDefaultInstance()
+	}
+
+	return &Manager{
+		client:        c,
+		clientAddress: clientAddress,
+	}, nil
+}
+
+// GetCurrentInstance returns the address of the current instance
+func (m *Manager) GetCurrentInstance() string {
+	return m.clientAddress
+}
+
+func (m *Manager) UpdateSettings(ctx context.Context, settings *cline.Settings, secrets *cline.Secrets) error {
+	request := &cline.UpdateSettingsRequestCli{
+		Metadata: &cline.Metadata{},
+		Settings: settings,
+		Secrets:  secrets,
+	}
+
+	// Call the updateSettingsCli RPC
+	_, err := m.client.State.UpdateSettingsCli(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to update settings: %w", err)
+	}
+
+	fmt.Println("Settings updated successfully")
+	fmt.Printf("Instance: %s\n", m.clientAddress)
+	return nil
+}
+
+func (m *Manager) GetState(ctx context.Context) (map[string]interface{}, error) {
+	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get state: %w", err)
+	}
+
+	var stateData map[string]interface{}
+	if err := json.Unmarshal([]byte(state.StateJson), &stateData); err != nil {
+		return nil, fmt.Errorf("failed to parse state: %w", err)
+	}
+
+	return stateData, nil
+}
+
+func (m *Manager) ListSettings(ctx context.Context) error {
+	// Get state
+	stateData, err := m.GetState(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Subset of fields we will print the values for
+	settingsFields := []string{
+		"apiConfiguration",
+		"telemetrySetting",
+		"planActSeparateModelsSetting",
+		"enableCheckpointsSetting",
+		"mcpMarketplaceEnabled",
+		"shellIntegrationTimeout",
+		"terminalReuseEnabled",
+		"mcpResponsesCollapsed",
+		"mcpDisplayMode",
+		"terminalOutputLineLimit",
+		"mode",
+		"preferredLanguage",
+		"openaiReasoningEffort",
+		"strictPlanModeEnabled",
+		"focusChainSettings",
+		"useAutoCondense",
+		"customPrompt",
+		"browserSettings",
+		"defaultTerminalProfile",
+		"yoloModeToggled",
+		"dictationSettings",
+		"autoCondenseThreshold",
+		"autoApprovalSettings",
+	}
+
+	// Render each field using the renderer
+	for _, field := range settingsFields {
+		if value, ok := stateData[field]; ok {
+			if err := RenderField(field, value, true); err != nil {
+				fmt.Printf("Error rendering %s: %v\n", field, err)
+			}
+			fmt.Println()
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) GetSetting(ctx context.Context, key string) error {
+	// Get state
+	stateData, err := m.GetState(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Convert kebab-case to camelCase path
+	parts := kebabToCamelPath(key)
+	rootField := parts[0]
+
+	// Get the value
+	value, found := getNestedValue(stateData, parts)
+	if !found {
+		return fmt.Errorf("setting '%s' not found", key)
+	}
+
+	// Render the value
+	if len(parts) == 1 {
+		// Top-level field: use RenderField for nice formatting
+		return RenderField(rootField, value, false)
+	} else {
+		// Nested field: simple print
+		fmt.Printf("%s: %s\n", key, formatValue(value, rootField, true))
+	}
+
+	return nil
+}
+
+// kebabToCamelPath converts a kebab-case path to camelCase
+// e.g., "auto-approval-settings.actions.read-files" -> "autoApprovalSettings.actions.readFiles"
+func kebabToCamelPath(path string) []string {
+	parts := strings.Split(path, ".")
+	for i, part := range parts {
+		parts[i] = kebabToCamel(part)
+	}
+	return parts
+}
+
+// kebabToCamel converts a single kebab-case string to camelCase
+// e.g., "auto-approval-settings" -> "autoApprovalSettings"
+func kebabToCamel(s string) string {
+	if s == "" {
+		return s
+	}
+
+	parts := strings.Split(s, "-")
+	if len(parts) == 1 {
+		return s
+	}
+
+	// First part stays lowercase, rest are capitalized
+	result := parts[0]
+	for i := 1; i < len(parts); i++ {
+		if parts[i] != "" {
+			result += strings.ToUpper(parts[i][:1]) + parts[i][1:]
+		}
+	}
+	return result
+}
+
+// getNestedValue retrieves a value from a nested map using dot notation
+// e.g., "autoApprovalSettings.actions.readFiles"
+func getNestedValue(data map[string]interface{}, parts []string) (interface{}, bool) {
+	current := interface{}(data)
+
+	for _, part := range parts {
+		// Try to access as map
+		if m, ok := current.(map[string]interface{}); ok {
+			if val, exists := m[part]; exists {
+				current = val
+				continue
+			}
+			return nil, false
+		}
+		return nil, false
+	}
+
+	return current, true
+}

package/pkg/cli/config/settings_renderer.go

@@ -0,0 +1,198 @@
+package config
+
+import (
+	"fmt"
+	"strings"
+)
+
+// sensitiveKeywords defines field name patterns that should be censored
+var sensitiveKeywords = []string{"key", "secret", "password", "cline-account-id"}
+
+// camelToKebab converts camelCase to kebab-case
+// e.g., "autoApprovalSettings" -> "auto-approval-settings"
+func camelToKebab(s string) string {
+	if s == "" {
+		return s
+	}
+
+	var result []rune
+	for i, r := range s {
+		if i > 0 && r >= 'A' && r <= 'Z' {
+			result = append(result, '-')
+		}
+		result = append(result, r|32) // Convert to lowercase (works for A-Z)
+	}
+	return string(result)
+}
+
+// isSensitiveField checks if a field name contains sensitive keywords
+func isSensitiveField(fieldName string) bool {
+	if fieldName == "" {
+		return false
+	}
+	
+	lowerName := strings.ToLower(fieldName)
+	for _, keyword := range sensitiveKeywords {
+		if strings.Contains(lowerName, keyword) {
+			return true
+		}
+	}
+	
+	return false
+}
+
+// formatValue formats a value for display, handling empty strings and censoring sensitive fields
+func formatValue(val interface{}, fieldName string, censor bool) string {
+	// Handle empty strings specifically
+	if str, ok := val.(string); ok && str == "" {
+		return "''"
+	}
+	
+	if censor && isSensitiveField(fieldName) {
+		valStr := fmt.Sprintf("%v", val)
+		if valStr != "" && valStr != "''" {
+			return "********"
+		}
+	}
+	
+	return fmt.Sprintf("%v", val)
+}
+
+// RenderField renders a single config field with proper formatting
+func RenderField(key string, value interface{}, censor bool) error {
+	switch key {
+	// Nested objects - render with header + nested fields
+	case "apiConfiguration":
+		return renderApiConfiguration(value, censor)
+	case "browserSettings":
+		return renderBrowserSettings(value, censor)
+	case "focusChainSettings":
+		return renderFocusChainSettings(value, censor)
+	case "dictationSettings":
+		return renderDictationSettings(value, censor)
+	case "autoApprovalSettings":
+		return renderAutoApprovalSettings(value, censor)
+
+	// Simple values - just print key: value
+	case "mode", "telemetrySetting", "preferredLanguage", "customPrompt",
+		"defaultTerminalProfile", "mcpDisplayMode", "openaiReasoningEffort",
+		"planActSeparateModelsSetting", "enableCheckpointsSetting",
+		"mcpMarketplaceEnabled", "terminalReuseEnabled",
+		"mcpResponsesCollapsed", "strictPlanModeEnabled",
+		"useAutoCondense", "yoloModeToggled", "shellIntegrationTimeout",
+		"terminalOutputLineLimit", "autoCondenseThreshold":
+		fmt.Printf("%s: %s\n", camelToKebab(key), formatValue(value, key, censor))
+		return nil
+
+	default:
+		return fmt.Errorf("unknown config field: %s", key)
+	}
+}
+
+// renderApiConfiguration renders the API configuration object
+func renderApiConfiguration(value interface{}, censor bool) error {
+	fmt.Println("api-configuration:")
+
+	configMap, ok := value.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("invalid api-configuration format")
+	}
+
+	// Print each field directly
+	for key, val := range configMap {
+		fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+	}
+
+	return nil
+}
+
+// renderBrowserSettings renders browser settings
+func renderBrowserSettings(value interface{}, censor bool) error {
+	fmt.Println("browser-settings:")
+
+	settingsMap, ok := value.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("invalid browser-settings format")
+	}
+
+	// Handle nested viewport if present
+	if viewport, ok := settingsMap["viewport"].(map[string]interface{}); ok {
+		fmt.Println("  viewport:")
+		for key, val := range viewport {
+			fmt.Printf("    %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+		}
+	}
+
+	// Print other fields
+	for key, val := range settingsMap {
+		if key != "viewport" {
+			fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+		}
+	}
+
+	return nil
+}
+
+// renderFocusChainSettings renders focus chain settings
+func renderFocusChainSettings(value interface{}, censor bool) error {
+	fmt.Println("focus-chain-settings:")
+
+	settingsMap, ok := value.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("invalid focus-chain-settings format")
+	}
+
+	for key, val := range settingsMap {
+		fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+	}
+
+	return nil
+}
+
+// renderDictationSettings renders dictation settings
+func renderDictationSettings(value interface{}, censor bool) error {
+	fmt.Println("dictation-settings:")
+
+	settingsMap, ok := value.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("invalid dictation-settings format")
+	}
+
+	for key, val := range settingsMap {
+		fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+	}
+
+	return nil
+}
+
+// renderAutoApprovalSettings renders auto approval settings
+func renderAutoApprovalSettings(value interface{}, censor bool) error {
+	fmt.Println("auto-approval-settings:")
+
+	settingsMap, ok := value.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("invalid auto-approval-settings format")
+	}
+
+	// Print top-level fields (skip version, handle actions specially)
+	for key, val := range settingsMap {
+		if key == "version" {
+			continue // Skip version
+		}
+
+		if key == "actions" {
+			// Handle nested actions with double indentation
+			fmt.Println("  actions:")
+			if actionsMap, ok := val.(map[string]interface{}); ok {
+				for actionKey, actionVal := range actionsMap {
+					fmt.Printf("    %s: %s\n", camelToKebab(actionKey), formatValue(actionVal, actionKey, censor))
+				}
+			}
+		} else {
+			// Print other fields normally (enabled, enableNotifications, favorites)
+			fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
+		}
+	}
+
+	return nil
+}