devtral medium

.changeset/bitter-maps-leave.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added getCwdHash proto

.changeset/breezy-bushes-raise.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-add OpenTelemetry integration

.changeset/calm-experts-think.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-removed multi-root feature flag

.changeset/chilly-sheep-rhyme.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Improve cerebras Qwen model performance by removing thinking tokens from the model input

.changeset/cli-version-injection.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add version information injection to CLI build script. The CLI binaries now include version, commit hash, build date, and builder information extracted from package.json and git, improving debugging and version tracking capabilities.

.changeset/dry-scissors-know.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Baseten Provider Model APIs Deprecation

.changeset/five-jokes-sing.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-allowing user to uncheck requesty base url

.changeset/fruity-tigers-wait.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added updateApiConfigurationPartial with FieldMask to allow for partial ApiProvider updates

.changeset/kind-boxes-remember.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Change available Cerebras models - limit to Qwen and llama 3.3 70b

.changeset/lucky-mayflies-arrive.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add auto-retry with exponential backof for failed API requests

.changeset/many-ligers-beam.md

@@ -0,0 +1,8 @@
+---
+"claude-dev": patch
+---
+
+Added checkpointTrackerErrorMessage to HistoryItem - restored with task, prevents re-initialization if timed out before
+Never re-init checkpoint tracker if it timed out before
+Warning at 7s that it's taking awhile, timeout and give up at 15s
+Fixed click to open settings - now opens to correct tab

.changeset/moody-crabs-relate.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+fix: mcp servers are not started when disabled

.changeset/nasty-vans-mate.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Refactor Git commit message generation to support output streaming.

.changeset/popular-flies-explode.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Introduce Claude Code support on Windows and fix E2BIG issues

.changeset/silent-grapes-cough.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added subscribeToCheckpoints proto

.changeset/three-groups-grin.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add UserAgent to Bedrock Client

.changeset/three-humans-type.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-auto-cleanup stale default instance config

.changeset/warm-carrots-stop.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added GPT-5 as reasoning model in openai.ts to pass correct parameters to SDK.

.changeset/wet-spiders-watch.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Change Cerebras Qwen 3 32b context window from 16k to 64k

.changeset/yellow-pens-behave.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add interactive provider configuration wizard with add/list capabilities, support for 8 API providers (Anthropic, OpenAI, OpenAI Native, OpenRouter, X AI, AWS Bedrock, Google Gemini, Ollama), and UpdateSettings gRPC implementation for persisting configurations to Cline Core state.

.clinerules/cline-overview.md

@@ -716,7 +716,7 @@ The Controller class manages MCP servers through the McpHub service:
 class Controller {
   mcpHub?: McpHub
 
-  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
+  constructor(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, webviewProvider: WebviewProvider) {
     this.mcpHub = new McpHub(this)
   }
 

.clinerules/hooks/PostToolUse.example

@@ -1,54 +0,0 @@
-#!/usr/bin/env bash
-# PostToolUse Hook Example
-# 
-# This hook runs AFTER a tool is executed. It can:
-# 1. Observe tool results and outcomes
-# 2. Add context for FUTURE tool uses via contextModification
-# 3. Log or track tool usage patterns
-#
-# IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-# The tool has already completed when this hook runs.
-
-# Read the hook input (JSON via stdin)
-input=$(cat)
-
-# Extract tool information
-tool_name=$(echo "$input" | jq -r '.postToolUse.toolName // "unknown"')
-parameters=$(echo "$input" | jq -r '.postToolUse.parameters // {}')
-result=$(echo "$input" | jq -r '.postToolUse.result // ""')
-success=$(echo "$input" | jq -r '.postToolUse.success // false')
-execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs // 0')
-
-# Example 1: Learning from file operations
-# Track successful file creations to build context about project structure
-# if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
-#   path=$(echo "$parameters" | jq -r '.path // ""')
-#   cat <<EOF
-# {
-#   "shouldContinue": true,
-#   "contextModification": "FILE_OPERATIONS: Successfully created '$path'. Future operations should maintain consistency with this file's patterns and structure."
-# }
-# EOF
-#   exit 0
-# fi
-
-# Example 2: Performance monitoring
-# Warn about slow operations
-# if [[ "$execution_time" -gt 5000 ]]; then
-#   cat <<EOF
-# {
-#   "shouldContinue": true,
-#   "contextModification": "PERFORMANCE: Tool '$tool_name' took ${execution_time}ms to complete. Consider optimizing future similar operations or breaking them into smaller steps."
-# }
-# EOF
-#   exit 0
-# fi
-
-# Example 3: Context injection for future tool uses
-# The context will be available in the NEXT API request
-cat <<EOF
-{
-  "shouldContinue": true,
-  "contextModification": "TOOL_RESULT: The tool '$tool_name' completed with success=$success. Consider validating the results before proceeding to the next step."
-}
-EOF

.clinerules/hooks/PostToolUse.example.cmd

@@ -1,16 +0,0 @@
-@echo off
-REM PostToolUse Hook Example - Windows Batch Version
-REM 
-REM This hook runs AFTER a tool is executed. It can:
-REM 1. Observe tool results and outcomes
-REM 2. Add context for FUTURE tool uses via contextModification
-REM 3. Log or track tool usage patterns
-REM
-REM IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-REM The tool has already completed when this hook runs.
-
-REM Simple example: Always allow continuation
-echo {"shouldContinue": true}
-
-REM To add context based on results, use:
-REM echo {"shouldContinue": true, "contextModification": "TOOL_RESULT: Operation completed successfully"}

.clinerules/hooks/PreToolUse.advanced.example.cmd

@@ -1,38 +0,0 @@
-@echo off
-REM PreToolUse Hook - Advanced Example with Input Parsing
-REM This version reads and parses the JSON input from stdin using PowerShell
-
-setlocal enabledelayedexpansion
-
-REM Read all input from stdin using PowerShell
-for /f "usebackq delims=" %%i in (`powershell -NoProfile -Command "[Console]::In.ReadToEnd()"`) do set "INPUT=%%i"
-
-REM Parse JSON and make decisions using PowerShell
-REM Note: We use -replace to handle special characters in the input
-powershell -NoProfile -Command ^
-  "$input = '%INPUT%' -replace \"'\", \"''\"; ^
-   try { ^
-     $json = $input | ConvertFrom-Json; ^
-     $toolName = $json.preToolUse.toolName; ^
-     $shouldBlock = $false; ^
-     $errorMsg = ''; ^
-     $context = ''; ^
-     if ($toolName -eq 'write_to_file') { ^
-       $path = $json.preToolUse.parameters.path; ^
-       if ($path -match '\\.js$') { ^
-         $shouldBlock = $true; ^
-         $errorMsg = 'Cannot create .js files in TypeScript project'; ^
-         $context = 'WORKSPACE_RULES: Use .ts/.tsx extensions only'; ^
-       } ^
-     } ^
-     $output = @{ ^
-       shouldContinue = -not $shouldBlock; ^
-     }; ^
-     if ($errorMsg) { $output.errorMessage = $errorMsg }; ^
-     if ($context) { $output.contextModification = $context }; ^
-     $output | ConvertTo-Json -Compress; ^
-   } catch { ^
-     @{ shouldContinue = $true } | ConvertTo-Json -Compress; ^
-   }"
-
-endlocal

.clinerules/hooks/PreToolUse.example

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-# PreToolUse Hook Example
-# 
-# This hook runs BEFORE a tool is executed. It can:
-# 1. Block execution by returning {"shouldContinue": false}
-# 2. Add context for FUTURE tool uses via contextModification
-# 3. Validate tool parameters
-#
-# IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-# The tool parameters are already determined when this hook runs.
-
-# Read the hook input (JSON via stdin)
-input=$(cat)
-
-# Extract tool information
-tool_name=$(echo "$input" | jq -r '.preToolUse.toolName // "unknown"')
-parameters=$(echo "$input" | jq -r '.preToolUse.parameters // {}')
-
-# Example 1: Validation - Block invalid operations
-# Uncomment to prevent creating .js files in a TypeScript project
-# if [[ "$tool_name" == "write_to_file" ]]; then
-#   path=$(echo "$parameters" | jq -r '.path // ""')
-#   if [[ "$path" == *.js ]]; then
-#     cat <<EOF
-# {
-#   "shouldContinue": false,
-#   "errorMessage": "VALIDATION FAILED: Cannot create .js files in TypeScript project. Please use .ts extension instead.",
-#   "contextModification": "WORKSPACE_RULES: This is a strict TypeScript project. All new files must use .ts or .tsx extensions."
-# }
-# EOF
-#     exit 0
-#   fi
-# fi
-
-# Example 2: Context injection for future tool uses
-# The context will be available in the NEXT API request after this tool completes
-cat <<EOF
-{
-  "shouldContinue": true,
-  "contextModification": "WORKSPACE_RULES: [For future tool uses] This is a TypeScript React project. When creating files, use .ts/.tsx extensions and include detailed comments explaining the purpose and usage of each function."
-}
-EOF

.clinerules/hooks/PreToolUse.example.cmd

@@ -1,15 +0,0 @@
-@echo off
-REM PreToolUse Hook Example - Windows Batch Version
-REM 
-REM This hook runs BEFORE a tool is executed. It can:
-REM 1. Block execution by returning {"shouldContinue": false}
-REM 2. Add context for FUTURE tool uses via contextModification
-REM 3. Validate tool parameters
-REM
-REM IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-
-REM Simple example: Always allow execution with workspace context
-echo {"shouldContinue": true, "contextModification": "WORKSPACE_RULES: This is a TypeScript project. Use .ts/.tsx extensions for new files."}
-
-REM To block execution, use:
-REM echo {"shouldContinue": false, "errorMessage": "Operation not allowed"}

.clinerules/hooks/README.md

@@ -1,290 +0,0 @@
-# Cline Hooks Documentation
-
-## Overview
-
-Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks are placed in the `.clinerules/hooks/` directory and run automatically when enabled.
-
-## Enabling Hooks
-
-1. Open Cline settings in VSCode
-2. Navigate to the Feature Settings section
-3. Check the "Enable Hooks" checkbox
-4. Hooks must be executable files (on Unix/Linux/macOS use `chmod +x hookname`)
-
-## Available Hooks
-
-### PreToolUse Hook
-- **When**: Runs BEFORE a tool is executed
-- **Purpose**: Validate parameters, block execution, or add context
-- **File**: `.clinerules/hooks/PreToolUse` (Unix/Linux/macOS) or `.clinerules/hooks/PreToolUse.bat/.cmd/.exe` (Windows)
-
-### PostToolUse Hook
-- **When**: Runs AFTER a tool completes
-- **Purpose**: Observe results, track patterns, or add context
-- **File**: `.clinerules/hooks/PostToolUse` (Unix/Linux/macOS) or `.clinerules/hooks/PostToolUse.bat/.cmd/.exe` (Windows)
-
-## Platform-Specific Guidance
-
-### Windows Hooks
-
-Windows hooks use different file extensions and syntax than Unix hooks. Cline automatically searches for hooks using your system's `PATHEXT` environment variable (typically `.COM;.EXE;.BAT;.CMD;.VBS;.JS;.WSF;.MSC`).
-
-**Recommended approach for Windows:**
-- Use `.cmd` or `.bat` batch files (most compatible)
-- See `PreToolUse.example.cmd` and `PostToolUse.example.cmd` for simple examples
-- See `PreToolUse.advanced.example.cmd` for PowerShell-based JSON parsing
-
-**Simple Windows Hook Example:**
-```batch
-@echo off
-REM Always allow execution with context
-echo {"shouldContinue": true, "contextModification": "WORKSPACE_RULES: TypeScript project"}
-```
-
-**Advanced Windows Hook with Input Parsing:**
-```batch
-@echo off
-setlocal enabledelayedexpansion
-
-REM Read stdin using PowerShell
-for /f "usebackq delims=" %%i in (`powershell -Command "[Console]::In.ReadToEnd()"`) do set "INPUT=%%i"
-
-REM Parse and process JSON
-powershell -Command ^
-  "$json = '%INPUT%' | ConvertFrom-Json; ^
-   $output = @{shouldContinue = $true}; ^
-   $output | ConvertTo-Json -Compress"
-```
-
-**Tips for Windows:**
-- Batch files don't require `chmod +x` - they're executable by default
-- Use `REM` for comments instead of `#`
-- PowerShell is available on all modern Windows systems
-- For complex logic, consider PowerShell scripts (`.ps1`) or compiled executables (`.exe`)
-
-### Unix/Linux/macOS Hooks
-
-Unix hooks are shell scripts without file extensions:
-- Must be executable: `chmod +x PreToolUse`
-- Must include shebang: `#!/usr/bin/env bash` or `#!/usr/bin/env node`
-- See `PreToolUse.example` and `PostToolUse.example` for bash examples
-
-## Context Injection Timing
-
-**IMPORTANT**: Context injected by hooks affects **FUTURE AI decisions**, not the current tool execution.
-
-### Why This Matters
-
-When a hook runs:
-1. The AI has already decided what tool to use and with what parameters
-2. The hook cannot modify those parameters
-3. Context from the hook is added to the conversation
-4. The AI sees this context in the **NEXT API request** and can adjust future decisions
-
-### PreToolUse Hook Flow
-```
-1. AI decides: "I'll use write_to_file with these parameters"
-2. PreToolUse hook runs → can block or add context
-3. If allowed, tool executes with original parameters
-4. Context is added to conversation
-5. Next API request includes this context
-6. AI adjusts future decisions based on context
-```
-
-### PostToolUse Hook Flow
-```
-1. Tool completes execution
-2. PostToolUse hook runs → observes results
-3. Hook adds context about the outcome
-4. Context is added to conversation
-5. Next API request includes this context
-6. AI can learn from the results
-```
-
-## Hook Input/Output
-
-### Input (via stdin as JSON)
-
-All hooks receive:
-```json
-{
-  "clineVersion": "string",
-  "hookName": "PreToolUse" | "PostToolUse",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "preToolUse": {  // Only for PreToolUse
-    "toolName": "string",
-    "parameters": {}
-  },
-  "postToolUse": {  // Only for PostToolUse
-    "toolName": "string",
-    "parameters": {},
-    "result": "string",
-    "success": boolean,
-    "executionTimeMs": number
-  }
-}
-```
-
-### Output (via stdout as JSON)
-
-All hooks must return:
-```json
-{
-  "shouldContinue": boolean,           // Required: Allow or block execution
-  "contextModification": "string",      // Optional: Context for future tool uses
-  "errorMessage": "string"             // Optional: Error details if blocking
-}
-```
-
-## Context Modification Format
-
-Use structured prefixes to help the AI understand context type:
-
-- `WORKSPACE_RULES:` - Project conventions and requirements
-- `FILE_OPERATIONS:` - File creation/modification patterns
-- `TOOL_RESULT:` - Outcomes of tool executions
-- `PERFORMANCE:` - Performance concerns
-- `VALIDATION:` - Validation results
-- Custom prefixes as needed
-
-Example:
-```bash
-cat <<EOF
-{
-  "shouldContinue": true,
-  "contextModification": "WORKSPACE_RULES: This is a TypeScript project. All new files must use .ts or .tsx extensions."
-}
-EOF
-```
-
-## Hook Execution Limits
-
-- **Timeout**: Hooks must complete within 30 seconds
-- **Context Size**: Context modifications are limited to 50KB
-- **Error Handling**: Unexpected file system errors are propagated; expected errors (file not found, permission denied) are handled silently
-
-## Common Use Cases
-
-### 1. Validation - Block Invalid Operations
-
-```bash
-#!/usr/bin/env bash
-input=$(cat)
-tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
-path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
-
-if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
-  cat <<EOF
-{
-  "shouldContinue": false,
-  "errorMessage": "Cannot create .js files in TypeScript project",
-  "contextModification": "WORKSPACE_RULES: Use .ts/.tsx extensions only"
-}
-EOF
-  exit 0
-fi
-
-echo '{"shouldContinue": true}'
-```
-
-### 2. Context Building - Learn from Operations
-
-```bash
-#!/usr/bin/env bash
-input=$(cat)
-tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
-success=$(echo "$input" | jq -r '.postToolUse.success')
-path=$(echo "$input" | jq -r '.postToolUse.parameters.path // ""')
-
-if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
-  cat <<EOF
-{
-  "shouldContinue": true,
-  "contextModification": "FILE_OPERATIONS: Created '$path'. Maintain consistency with this file's patterns in future operations."
-}
-EOF
-else
-  echo '{"shouldContinue": true}'
-fi
-```
-
-### 3. Performance Monitoring
-
-```bash
-#!/usr/bin/env bash
-input=$(cat)
-execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs')
-tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
-
-if [[ "$execution_time" -gt 5000 ]]; then
-  cat <<EOF
-{
-  "shouldContinue": true,
-  "contextModification": "PERFORMANCE: Tool '$tool_name' took ${execution_time}ms. Consider optimizing future similar operations."
-}
-EOF
-else
-  echo '{"shouldContinue": true}'
-fi
-```
-
-### 4. Logging and Telemetry
-
-```bash
-#!/usr/bin/env bash
-input=$(cat)
-
-# Log to file
-echo "$input" >> ~/.cline/hook-logs/tool-usage.jsonl
-
-# Allow execution
-echo '{"shouldContinue": true}'
-```
-
-## Multi-Root Workspaces
-
-If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks will run and their results will be combined:
-
-- **shouldContinue**: If ANY hook returns false, execution is blocked
-- **contextModification**: All context modifications are concatenated
-- **errorMessage**: All error messages are concatenated
-
-## Troubleshooting
-
-### Hook Not Running
-- Ensure the "Enable Hooks" setting is checked
-- Verify the hook file is executable (`chmod +x hookname`)
-- Check the hook file has no syntax errors
-- Look for errors in VSCode's Output panel (Cline channel)
-
-### Hook Timing Out
-- Reduce complexity of the hook script
-- Avoid expensive operations (network calls, heavy computations)
-- Consider moving complex logic to a background process
-
-### Context Not Affecting Behavior
-- Remember: context affects FUTURE decisions, not the current tool
-- Use PreToolUse for validation (blocking) if you need immediate effect
-- Ensure context modifications are clear and actionable
-- Check that context isn't being truncated (50KB limit)
-
-## Security Considerations
-
-- Hooks run with the same permissions as VSCode
-- Be cautious with hooks from untrusted sources
-- Review hook scripts before enabling them
-- Consider using `.gitignore` to avoid committing sensitive hook logic
-- Hooks can access all workspace files and environment variables
-
-## Best Practices
-
-1. **Keep hooks fast** - Aim for <100ms execution time
-2. **Make context actionable** - Be specific about what the AI should do
-3. **Use structured prefixes** - Help the AI categorize context
-4. **Handle errors gracefully** - Always return valid JSON
-5. **Log for debugging** - Keep logs of hook executions for troubleshooting
-6. **Test incrementally** - Start with simple hooks and add complexity
-7. **Document your hooks** - Add comments explaining the purpose and logic

.clinerules/workflows/git-branch-analysis.md

@@ -6,14 +6,28 @@ Analyze the current branch's changes against main to provide informed insights a
 ## Step 1: Gather Git Information
 <important>Do not return any text or conversation other than what is necessary to run these commands</important>
 
-**Run the following command to get the latest changes (bash):**
-```bash
-B=$(for c in main master origin/main origin/master; do git rev-parse --verify -q "$c" >/dev/null && echo "$c" && break; done); B=${B:-HEAD}; r(){ git branch --show-current; printf "=== STATUS ===\n"; git status --porcelain | cat; printf "=== COMMIT MESSAGES ===\n"; git log "$B"..HEAD --oneline | cat; printf "=== CHANGED FILES ===\n"; git diff "$B" --name-only | cat; printf "=== FULL DIFF ===\n"; git diff "$B" | cat; }; L=$(r | wc -l); if [ "$L" -gt 500 ]; then r > cline-git-analysis.temp && echo "::OUTPUT_FILE=cline-git-analysis.temp"; else r; fi
-```
+**First, check the expected output size:**
+   ```shell
+   (git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat) | wc -l
+   ```
 
-```powershell
-$B=$null;foreach($c in 'main','master','origin/main','origin/master'){git rev-parse --verify -q $c *> $null;if($LASTEXITCODE -eq 0){$B=$c;break}};if(-not $B){$B='HEAD'};function r([string]$b){git rev-parse --abbrev-ref HEAD; '=== STATUS ==='; git status --porcelain | cat; '=== COMMIT MESSAGES ==='; git log "$b"..HEAD --oneline | cat; '=== CHANGED FILES ==='; git diff "$b" --name-only | cat; '=== FULL DIFF ==='; git diff "$b" | cat};$out=r $B|Out-String;$lines=($out -split "`r?`n").Count;if($lines -gt 500){$out|Set-Content -NoNewline cline-git-analysis.temp; '::OUTPUT_FILE=cline-git-analysis.temp'}else{$out}
-```
+**If the expected line count is greater than 500 lines, use the file-based approach:**
+   ```shell
+   git branch --show-current > cline-git-analysis.temp && echo "=== STATUS ===" >> cline-git-analysis.temp && git status --porcelain >> cline-git-analysis.temp && echo "=== COMMIT MESSAGES ===" >> cline-git-analysis.temp && git log main..HEAD --oneline >> cline-git-analysis.temp && echo "=== CHANGED FILES ===" >> cline-git-analysis.temp && git diff main --name-only >> cline-git-analysis.temp && echo "=== FULL DIFF ===" >> cline-git-analysis.temp && git diff main >> cline-git-analysis.temp
+   ```
+
+   Then, read the file using the read_file tool. After you have read the file but before you proceed with subsequent steps, delete it:
+   ```shell
+   rm cline-git-analysis.temp
+   ```
+
+**If the expected line count is 500 lines or fewer, use the direct approach:**
+   ```shell
+   git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat
+   ```
+
+<important>If using the direct approach, pipe outputs through `cat` to avoid interactive terminals. If the user's shell is not bash/zsh, adjust the command and chaining
+ syntax accordingly.</important>
 
 ## Step 2: Silent, Structured Analysis Phase
 - Analyze all git output without providing commentary or narration

.clinerules/workflows/pr-review.md

@@ -219,9 +219,6 @@ EOF
 
 ## Basic PR Commands
 ```bash
-# Get current PR number
-gh pr view --json number -q .number
-
 # List open PRs
 gh pr list
 

.codespellrc

@@ -0,0 +1,6 @@
+[codespell]
+# Ref: https://github.com/codespell-project/codespell#using-a-config-file
+skip = .git*,*.svg,package-lock.json,*.css,.codespellrc,locales
+check-hidden = true
+ignore-regex = (\b(optIn|isTaller)\b|https://\S+)
+# ignore-words-list =

.env.example

@@ -1,116 +0,0 @@
-# Cline Development Environment Variables
-# Copy this file to .env and fill in your actual values
-# Values should be obtained from 1Password shared vault for development
-
-# ============================================================================
-# DEVELOPMENT FLAGS
-# Recomend not changing these unless you know what you're doing they are set by the launch.json normally
-# ============================================================================
-# IS_DEV=true
-# CLINE_ENVIRONMENT=local
-
-# ============================================================================
-# POSTHOG TELEMETRY (Existing)
-# ============================================================================
-# Get these values from 1Password shared vault
-TELEMETRY_SERVICE_API_KEY=your-posthog-telemetry-api-key
-ERROR_SERVICE_API_KEY=your-posthog-error-tracking-api-key
-
-# ============================================================================
-# TELEMETRY PROVIDER CONTROL
-# ============================================================================
-# Control which telemetry providers are active
-POSTHOG_TELEMETRY_ENABLED=true          # Enable PostHog telemetry (default: true)
-                                        # Set to false to disable Telemetry completely
-
-# ============================================================================
-# OPENTELEMETRY (Optional - for advanced telemetry)
-# ============================================================================
-# OpenTelemetry provides flexible telemetry collection with multiple export options
-# Can run alongside PostHog or independently
-# Primary focus: Logs (events), with optional metrics support
-
-# Enable OpenTelemetry (set to 1 to enable)
-# OTEL_TELEMETRY_ENABLED=1
-
-# Exporters: "console" for local debugging, "otlp" for remote collector
-# Logs are the primary signal (recommended)
-# OTEL_LOGS_EXPORTER=console
-# OTEL_METRICS_EXPORTER=otlp
-
-# OTLP Protocol: "grpc", "http/json", or "http/protobuf"
-# OTEL_EXPORTER_OTLP_PROTOCOL=grpc
-
-# OTLP Endpoint (without /v1/logs or /v1/metrics path - auto-appended)
-# For gRPC: use "localhost:4317" (no http:// prefix)
-# For HTTP: use "http://localhost:4318"
-# OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
-
-# OTLP Headers (for authentication, e.g., bearer tokens)
-# OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token-here
-
-# Use insecure gRPC connections (for local testing only, NOT for production)
-# OTEL_EXPORTER_OTLP_INSECURE=true
-
-# Metric export interval in milliseconds (default: 60000)
-# OTEL_METRIC_EXPORT_INTERVAL=10000
-
-# Batch configuration for logs (optional)
-# OTEL_LOG_BATCH_SIZE=512              # Max logs per batch (default: 512)
-# OTEL_LOG_BATCH_TIMEOUT=5000          # Max wait time in ms (default: 5000)
-# OTEL_LOG_MAX_QUEUE_SIZE=2048         # Max queue size (default: 2048)
-
-# Enable detailed export diagnostics (for debugging)
-# TEL_DEBUG_DIAGNOSTICS=true
-
-# Advanced: Separate endpoints for metrics and logs (optional)
-# OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf
-# OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://metrics.example.com:4318
-# OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=grpc
-# OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=logs.example.com:4317
-
-# Example configurations:
-#
-# Console debugging (logs only):
-#   OTEL_TELEMETRY_ENABLED=1
-#   OTEL_LOGS_EXPORTER=console
-#   TEL_DEBUG_DIAGNOSTICS=true
-#
-# OTLP with gRPC (insecure, for local testing):
-#   OTEL_TELEMETRY_ENABLED=1
-#   OTEL_LOGS_EXPORTER=otlp
-#   OTEL_EXPORTER_OTLP_PROTOCOL=grpc
-#   OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
-#   OTEL_EXPORTER_OTLP_INSECURE=true
-#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
-#
-# OTLP with HTTP/JSON (production):
-#   OTEL_TELEMETRY_ENABLED=1
-#   OTEL_LOGS_EXPORTER=otlp
-#   OTEL_EXPORTER_OTLP_PROTOCOL=http/json
-#   OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.example.com
-#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
-
-# ============================================================================
-# OPTIONAL DEVELOPMENT SETTINGS
-# ============================================================================
-# Uncomment and modify as needed for development
-
-# Multi-root workspace debugging
-# MULTI_ROOT_TRACE=true
-
-# gRPC recorder for testing
-# GRPC_RECORDER_ENABLED=true
-# GRPC_RECORDER_FILE_NAME=test-recording
-
-# Test mode
-# E2E_TEST=true
-# IS_TEST=true
-
-# ============================================================================
-# USAGE INSTRUCTIONS
-# ============================================================================
-# 1. Copy this file: cp .env.example .env
-# 2. Get PostHog keys from 1Password shared vault
-# 3. Update the values in .env
-# 4. The .env file is gitignored for security

.eslintrc.json

@@ -0,0 +1,34 @@
+{
+	"root": true,
+	"parser": "@typescript-eslint/parser",
+	"parserOptions": {
+		"ecmaVersion": 6,
+		"sourceType": "module"
+	},
+	"plugins": ["@typescript-eslint", "eslint-rules"],
+	"rules": {
+		"@typescript-eslint/naming-convention": [
+			"warn",
+			{
+				"selector": "import",
+				"format": ["camelCase", "PascalCase"]
+			}
+		],
+		"@typescript-eslint/semi": "off",
+		"curly": "warn",
+		"eqeqeq": "warn",
+		"no-throw-literal": "warn",
+		"semi": "off",
+		"react-hooks/exhaustive-deps": "off",
+		"eslint-rules/no-protobuf-object-literals": "error",
+		"eslint-rules/no-direct-vscode-api": "warn",
+		"no-restricted-syntax": [
+			"error",
+			{
+				"selector": "VariableDeclarator[id.type=\"ObjectPattern\"][init.object.name=\"process\"][init.property.name=\"env\"]",
+				"message": "Use process.env.VARIABLE_NAME directly instead of destructuring"
+			}
+		]
+	},
+	"ignorePatterns": ["out", "dist", "**/*.d.ts"]
+}

.github/CODEOWNERS

@@ -1,4 +1 @@
-/docs/
-/.github/   @saoudrizwan @garoth @sjf
-/README.md  @saoudrizwan @nickbaumann98
-/src/core/storage/ @celestial-vault
+*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv @Garoth

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,70 +1,70 @@
 name: 🐛 Bug Report
 description: File a bug report
-labels: ['bug']
+labels: ["bug"]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        **Important:** All bug reports must be reproducible using Claude Sonnet 4.5. Cline uses complex prompts so less capable models may not work as expected.
-  - type: dropdown
-    id: plugin-type
-    attributes:
-      label: Plugin Type
-      description: Which plugin are you reporting a bug for?
-      options:
-        - VSCode Extension
-        - JetBrains Plugin
-        - CLI
-      default: 0
-    validations:
-      required: true
-  - type: input
-    id: cline-version
-    attributes:
-      label: Cline Version
-      description: What version of Cline are you using? (You can find this at the bottom of the Settings view)
-      placeholder: 'e.g., 1.2.3'
-    validations:
-      required: true
-  - type: textarea
-    id: what-happened
-    attributes:
-      label: What happened?
-      description: Also tell us, what did you expect to happen?
-      placeholder: Tell us what you see!
-    validations:
-      required: true
-  - type: textarea
-    id: steps
-    attributes:
-      label: Steps to reproduce
-      description: How do you trigger this bug? Please walk us through it step by step.
-      value: |
-        1.
-        2.
-        3.
-    validations:
-      required: false
-  - type: input
-    id: provider-model
-    attributes:
-      label: Provider/Model
-      description: What provider and model were you using when the issue occurred?
-      placeholder: 'e.g., cline:anthropic/claude-sonnet-4.5, gemini:gemini-2.5-pro-exp-03-25'
-    validations:
-      required: false
-  - type: textarea
-    id: system-info
-    attributes:
-      label: System Information
-      description: What operating system and hardware are you using?
-      placeholder: |
-        Operating System: Windows 11, macOS Sonoma, Ubuntu 22.04, etc.
-        Hardware: CPU, GPU, RAM specifications if relevant
-        e.g.,
-        OS: Windows 11
-        CPU: Intel Core i7-11700K
-        GPU: NVIDIA GeForce RTX 3070
-        RAM: 32GB DDR4
-    validations:
-      required: false
+    - type: markdown
+      attributes:
+          value: |
+              **Important:** All bug reports must be reproducible using Claude 3.5 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
+    - type: textarea
+      id: what-happened
+      attributes:
+          label: What happened?
+          description: Also tell us, what did you expect to happen?
+          placeholder: Tell us what you see!
+      validations:
+          required: true
+    - type: textarea
+      id: steps
+      attributes:
+          label: Steps to reproduce
+          description: How do you trigger this bug? Please walk us through it step by step.
+          value: |
+              1.
+              2.
+              3.
+      validations:
+          required: true
+    - type: textarea
+      id: logs
+      attributes:
+          label: Relevant API REQUEST output
+          description: Please copy and paste any relevant output. This will be automatically formatted into code, so no need for backticks.
+          render: shell
+    - type: input
+      id: provider-model
+      attributes:
+          label: Provider/Model
+          description: What provider and model were you using when the issue occurred?
+          placeholder: "e.g., cline:anthropic/claude-3.7-sonnet, gemini:gemini-2.5-pro-exp-03-25"
+      validations:
+          required: true
+    - type: input
+      id: operating-system
+      attributes:
+          label: Operating System
+          description: What operating system are you using?
+          placeholder: "e.g., Windows 11, macOS Sonoma, Ubuntu 22.04"
+      validations:
+          required: true
+    - type: textarea
+      id: system-info
+      attributes:
+          label: System Info
+          description: What system information is relevant to the issue?
+          placeholder: "e.g., CPU: Intel Core i7-11700K, GPU: NVIDIA GeForce RTX 3070, RAM: 32GB DDR4"
+      validations:
+          required: true
+    - type: input
+      id: cline-version
+      attributes:
+          label: Cline Version
+          description: What version of Cline are you using? (You can find this at the bottom of the Settings view)
+          placeholder: "e.g., 1.2.3"
+      validations:
+          required: true
+    - type: textarea
+      id: additional-context
+      attributes:
+          label: Additional context
+          description: Add any other context about the problem here, such as screenshots or related issues.

.github/ISSUE_TEMPLATE/feature_contribution.yml

@@ -0,0 +1,116 @@
+name: 💡 Feature Proposal & Contribution
+description: Propose a new feature or improvement, and optionally offer to implement feature as a contributor
+labels: ["proposal"]
+body:
+    - type: markdown
+      attributes:
+          value: |
+              **Feature Proposal & Contribution for Cline**
+
+              Thank you for proposing a feature or improvement for Cline! This template helps us understand the problem, evaluate the solution, and coordinate implementation.
+
+              **For detailed proposals:** Please provide comprehensive information to enable fast prioritization and discussion.
+              **For contribution offers:** You can indicate your willingness to implement the feature yourself.
+
+              Before submitting:
+              - Search existing [Issues](https://github.com/cline/cline/issues) and [Discussions](https://github.com/cline/cline/discussions) to avoid duplicates
+              - Read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md) if you plan to contribute
+              - Don't start implementation until the proposal is reviewed and approved
+
+    - type: textarea
+      id: problem-description
+      attributes:
+          label: What problem does this solve?
+          description: |
+              Describe the problem clearly from a user's point of view. Focus on why this matters, who it affects, and when it occurs.
+
+              ✅ Good examples:
+              - "LLM provider returns 400 error when nearing the context window instead of truncating"
+              - "Submit button is invisible in dark mode"
+              - "Users can't easily share their Cline configurations with team members"
+
+              ❌ Avoid vague descriptions:
+              - "Performance is bad"
+              - "UI needs work"
+
+              Your description should include:
+              - Who is affected?
+              - When does it happen?
+              - What's the current vs expected behavior?
+              - What is the impact?
+          placeholder: Be specific about the problem, who it affects, and the impact.
+      validations:
+          required: true
+
+    - type: textarea
+      id: proposed-solution
+      attributes:
+          label: What's the proposed solution?
+          description: |
+              Describe how the problem should be solved. Be specific about UX, system behavior, and any flows that would change.
+
+              ✅ Good examples:
+              - "Add error handling immediately after attempting to create the llm stream and retry after manually truncating"
+              - "Update button styling to ensure contrast in all themes"
+              - "Add export/import functionality in settings with JSON format"
+
+              ❌ Avoid vague solutions:
+              - "Improve performance"
+              - "Fix the bug"
+
+              Your solution should include:
+              - What exactly will change?
+              - How will users interact with it?
+              - What's the expected outcome?
+          placeholder: Describe the proposed changes and how they solve the problem.
+      validations:
+          required: false
+
+    - type: dropdown
+      id: contribution-intent
+      attributes:
+          label: Are you interested in implementing this?
+          description: Let us know if you'd like to contribute to this feature
+          options:
+              - "No, just proposing the idea"
+              - "Yes, I'd like to implement this myself"
+              - "Yes, I'd like to collaborate with others"
+              - "Maybe, depending on complexity and guidance"
+      validations:
+          required: false
+
+    - type: textarea
+      id: implementation-approach
+      attributes:
+          label: Implementation approach (if contributing)
+          description: |
+              **Only fill this out if you selected "Yes" above.**
+
+              How do you plan to implement this? Include:
+              - High-level technical approach
+              - Files/components that would be affected
+              - Any new dependencies required
+              - Potential challenges or considerations you've identified
+
+              This helps us provide better guidance and ensures alignment before you start coding.
+          placeholder: "My implementation approach would be..."
+
+    - type: checkboxes
+      id: checklist
+      attributes:
+          label: Proposal checklist
+          options:
+              - label: I've checked for existing issues or related proposals
+                required: true
+              - label: I understand this needs review before implementation can start
+                required: true
+
+    - type: checkboxes
+      id: contribution-checklist
+      attributes:
+          label: Contribution checklist (if contributing)
+          description: Only check these if you plan to contribute
+          options:
+              - label: I've read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
+              - label: I'm willing to make changes based on feedback
+              - label: I understand the code review process and requirements

.github/pull_request_template.md

@@ -2,14 +2,15 @@
 Thank you for contributing to Cline!
 
 ⚠️ Important: Before submitting this PR, please ensure you have:
-- For feature requests: Created a discussion in our Feature Requests discussions board https://github.com/cline/cline/discussions/categories/feature-requests and received approval from core maintainers before implementation
-- For all changes: Link the associated issue/discussion in the "Related Issue" section below
+- Opened an issue and discussed your proposed changes with the community / contributors
+- Received approval from a core Cline contributor prior to proceeding with the implementation
+- Link the associated issue in the "Related Issue" section
 
 Limited exceptions:
-Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly without prior discussion.
+Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly.
 
 Why this requirement?
-We deeply appreciate all community contributions - they are essential to Cline's success! To ensure the best use of everyone's time and maintain project direction, we use our Feature Requests discussions board to gauge community interest and validate feature ideas before implementation begins. This helps us focus development efforts on features that will benefit the most users.
+We deeply appreciate all community contributions - they are the core reason we're able to operate successfully and keep innovating! We welcome community input and want to make it as easy as possible for people to submit quality work. This process helps our core maintainers review new ideas faster and saves contributor time by ensuring you have the go-ahead before spending time on implementation.
 -->
 
 ### Related Issue

.github/workflows/codespell.yml

@@ -0,0 +1,28 @@
+# Codespell configuration is within .codespellrc
+---
+name: Codespell
+
+on:
+    push:
+        branches: [main]
+    pull_request:
+        branches: [main]
+
+permissions:
+    contents: read
+
+jobs:
+    codespell:
+        if: false
+        name: Check for spelling errors
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Annotate locations with typos
+              uses: codespell-project/codespell-problem-matcher@v1
+            - name: Codespell
+              uses: codespell-project/actions-codespell@v2
+              with:
+                  only_warn: 1

.github/workflows/label-jetbrains-issues.yml

@@ -1,53 +0,0 @@
-name: Auto-label Issues
-
-on:
-  issues:
-    types: [opened, edited]
-
-jobs:
-  label:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          script: |
-            const body = context.payload.issue.body || '';
-            const labels = context.payload.issue.labels.map(l => l.name);
-            
-            // Check if JetBrains Plugin is selected
-            if (body.match(/###\s*Plugin Type\s*\n+JetBrains Plugin/i)) {
-              if (!labels.includes('JetBrains')) {
-                await github.rest.issues.addLabels({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: context.issue.number,
-                  labels: ['JetBrains']
-                });
-              }
-            }
-
-            // Check if VSCode Extension is selected
-            if (body.match(/###\s*Plugin Type\s*\n+VSCode Extension/i)) {
-              if (!labels.includes('VS Code')) {
-                await github.rest.issues.addLabels({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: context.issue.number,
-                  labels: ['VS Code']
-                });
-              }
-            }
-
-            // Check if CLI is selected
-            if (body.match(/###\s*Plugin Type\s*\n+CLI/i)) {
-              if (!labels.includes('CLI')) {
-                await github.rest.issues.addLabels({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: context.issue.number,
-                  labels: ['CLI']
-                });
-              }
-            }

.github/workflows/publish-nightly.yml

@@ -1,83 +0,0 @@
-name: "Publish Nightly Release"
-
-on:
-  schedule:
-    - cron: '0 12 * * *'  # 4 AM PST (UTC-8) = 12 UTC
-  workflow_dispatch:
-
-permissions:
-    contents: write
-    packages: write
-    checks: write
-    pull-requests: write
-
-jobs:
-    test:
-        uses: ./.github/workflows/test.yml
-
-    publish:
-        needs: test
-        name: Publish Cline (Nightly) Extension
-        if: github.repository == 'cline/cline'
-        runs-on: ubuntu-latest
-        environment: PublishNightly
-
-        steps:
-            - uses: actions/checkout@v4
-
-            - name: Check for recent commits
-              run: |
-                if [ $(git rev-list --count HEAD --since="24 hours ago") -eq 0 ]; then
-                  echo "No commits in last 24 hours, exiting"
-                  exit 0
-                fi
-                echo "Found recent commits, proceeding with build"
-                
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: "lts/*"
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
-
-            - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm ci --include=optional
-
-            - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm ci --include=optional
-
-            - name: Install Publishing Tools
-              run: npm install -g @vscode/vsce ovsx
-
-            - name: Publish Extension as Pre-release
-              env:
-                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
-                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
-                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
-                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
-                  CLINE_ENVIRONMENT: production
-                  # OpenTelemetry production defaults (can be overridden at runtime)
-                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
-                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
-                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
-                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
-                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
-              run: npm run publish:marketplace:nightly

.github/workflows/publish.yml

@@ -95,19 +95,9 @@ jobs:
                   VSCE_PAT: ${{ secrets.VSCE_PAT }}
                   OVSX_PAT: ${{ secrets.OVSX_PAT }}
                   CLINE_ENVIRONMENT: production
-                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
-                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
-                  # OpenTelemetry production defaults (can be overridden at runtime)
-                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
-                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
-                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
-                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
-                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
               run: |
                   # Required to generate the .vsix
-                  vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+                  vsce package --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
                   if [ "${{ github.event.inputs.release-type }}" = "pre-release" ]; then
                     npm run publish:marketplace:prerelease

.github/workflows/release-standalone.yml

@@ -1,183 +0,0 @@
-name: Release Standalone CLI
-
-on:
-  push:
-    tags:
-      - 'v*.*.*'
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to release (e.g., v3.32.6)'
-        required: true
-        type: string
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    name: Build ${{ matrix.platform }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: macos-13
-            platform: darwin-x64
-            arch: x64
-          - os: macos-14
-            platform: darwin-arm64
-            arch: arm64
-          - os: ubuntu-latest
-            platform: linux-x64
-            arch: x64
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-      
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.24'
-          cache-dependency-path: cli/go.sum
-      
-      - name: Install dependencies
-        run: npm ci
-      
-      - name: Install webview dependencies
-        run: cd webview-ui && npm ci
-      
-      - name: Download Node.js binaries
-        run: npm run download-node
-
-      - name: Download ripgrep binaries
-        run: npm run download-ripgrep
-
-      - name: Build CLI binaries
-        run: npm run compile-cli
-      
-      - name: Build standalone CLI package
-        run: npm run compile-standalone-cli
-        env:
-          NODE_ENV: production
-      
-      - name: Get version
-        id: version
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT
-          else
-            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          fi
-      
-      - name: Rename package
-        run: |
-          cd dist-standalone
-          mv standalone-cli.zip cline-${{ steps.version.outputs.version }}-${{ matrix.platform }}.tar.gz
-      
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: cline-${{ matrix.platform }}
-          path: dist-standalone/cline-${{ steps.version.outputs.version }}-${{ matrix.platform }}.tar.gz
-          retention-days: 1
-
-  release:
-    name: Create Release
-    needs: build
-    runs-on: ubuntu-latest
-    environment: publish
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: artifacts
-      
-      - name: Get version
-        id: version
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT
-          else
-            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          fi
-      
-      - name: Display structure
-        run: ls -R artifacts/
-      
-      - name: Create Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ steps.version.outputs.version }}
-          name: Cline CLI ${{ steps.version.outputs.version }}
-          draft: false
-          prerelease: false
-          generate_release_notes: true
-          files: |
-            artifacts/cline-darwin-x64/cline-${{ steps.version.outputs.version }}-darwin-x64.tar.gz
-            artifacts/cline-darwin-arm64/cline-${{ steps.version.outputs.version }}-darwin-arm64.tar.gz
-            artifacts/cline-linux-x64/cline-${{ steps.version.outputs.version }}-linux-x64.tar.gz
-          body: |
-            ## Installation
-            
-            Install Cline CLI with a single command:
-            
-            ```bash
-            curl -fsSL https://raw.githubusercontent.com/cline/cline/main/scripts/install.sh | bash
-            ```
-            
-            ### Platform-Specific Downloads
-            
-            - **macOS (Intel)**: `cline-${{ steps.version.outputs.version }}-darwin-x64.tar.gz`
-            - **macOS (Apple Silicon)**: `cline-${{ steps.version.outputs.version }}-darwin-arm64.tar.gz`
-            - **Linux (x64)**: `cline-${{ steps.version.outputs.version }}-linux-x64.tar.gz`
-            
-            ### Manual Installation
-            
-            1. Download the appropriate package for your platform
-            2. Extract: `tar -xzf cline-*.tar.gz`
-            3. Move to installation directory: `mv cline-* ~/.cline`
-            4. Add to PATH: `export PATH="$HOME/.cline/bin:$PATH"`
-            
-            ### What's Included
-
-            - ✅ Node.js v22.15.0 (bundled)
-            - ✅ Cline CLI binary
-            - ✅ Cline Host bridge
-            - ✅ Cline Core (TypeScript compiled)
-            - ✅ Ripgrep v14.1.1 (for file searching)
-            - ✅ All dependencies
-            
-            ### Getting Started
-            
-            ```bash
-            # Verify installation
-            cline version
-            
-            # Sign in
-            cline auth login
-            
-            # Get help
-            cline --help
-            ```
-            
-            ### Documentation
-            
-            - [Installation Guide](https://docs.cline.bot/getting-started/installing-cline)
-            - [CLI Documentation](https://docs.cline.bot/exploring-clines-tools/cline-tools-guide)
-            - [GitHub Repository](https://github.com/cline/cline)
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
-          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
-          CLINE_ENVIRONMENT: production

.github/workflows/test.yml

@@ -1,9 +1,6 @@
 name: Tests
 
 on:
-    push:
-        branches:
-            - main
     workflow_dispatch:
     pull_request:
         branches:
@@ -17,45 +14,7 @@ permissions:
     pull-requests: write # Needed to add comments/annotations to PRs
 
 jobs:
-    quality-checks:
-        runs-on: ubuntu-latest
-        name: Quality Checks
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v4
-
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
-              with:
-                  node-version: 22
-
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
-
-            - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm ci
-
-            - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm ci
-
-            - name: Run Quality Checks (Parallel)
-              run: npm run ci:check-all
-
     test:
-        needs: quality-checks
         strategy:
             fail-fast: false
             matrix:
@@ -74,6 +33,18 @@ jobs:
               with:
                   node-version: 22
 
+            # Setup Python for coverage script
+            - name: Setup Python
+              uses: actions/setup-python@v4
+              with:
+                  python-version: "3.10"
+
+            - name: Install Python dependencies
+              run: |
+                  python -m pip install --upgrade pip
+                  pip install requests
+
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
             - name: Cache root dependencies
               uses: actions/cache@v4
               id: root-cache
@@ -81,6 +52,7 @@ jobs:
                   path: node_modules
                   key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
 
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
             - name: Cache webview-ui dependencies
               uses: actions/cache@v4
               id: webview-cache
@@ -96,45 +68,61 @@ jobs:
               if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
+            - name: Install xvfb on Linux
+              if: runner.os == 'Linux'
+              run: sudo apt-get update && sudo apt-get install -y xvfb
+
+            - name: Install local modules on windows
+              if: runner.os == 'Windows' && steps.root-cache.outputs.cache-hit == 'true'
+              run: |
+                  npm install eslint-plugin-eslint-rules 
+                  cd webview-ui/ && npm install eslint-plugin-eslint-rules
+
             - name: Set up NPM on Windows
               if: runner.os == 'Windows'
               run: |
                   npm config set script-shell "C:\\Program Files\\Git\\bin\\bash.exe"
 
-            # Build the extension and tests (without redundant checks)
+            - name: Type Check
+              run: npm run check-types
+
+            - name: ESLint Check
+              run: npm run lint
+
+            - name: Prettier / Format Check
+              run: npm run format
+
+            # Build the extension before running tests
             - name: Build Tests and Extension
-              id: build_step
-              run: npm run ci:build
+              run: npm run pretest
 
-            - name: Unit Tests with coverage - Linux
-              id: unit_tests_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+            # Unit Tests disabled due to module system conflicts between backend and webview-ui
+            # - name: Unit Tests
+            #   run: npm run test:unit
+
+            # Run extension tests with coverage
+            - name: Extension Tests with Coverage
+              id: extension_coverage
+              continue-on-error: true
               run: |
-                  npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
-
-            - name: Unit Tests - Non-Linux
-              id: unit_tests_non_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
-              run: |
-                  npm run test:unit
-
-            - name: Extension Integration Tests - Linux
-              id: integration_tests_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              run: xvfb-run -a npm run test:coverage
-
-            - name: Extension Integration Tests - Non-Linux
-              id: integration_tests_non_linux
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
-              run: npm run test:integration
+                  node ./scripts/test-ci.js > extension_coverage.txt 2>&1
+                  # Default the encoding to UTF-8 - It's not the default on Windows
+                  PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage extension_coverage.txt --type=extension --github-output --verbose
 
+            # Run webview tests with coverage
             - name: Webview Tests with Coverage
-              id: webview_tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              id: webview_coverage
+              continue-on-error: true
               run: |
                   cd webview-ui
-                  npm run test:coverage
+                  # Ensure coverage dependency is installed
+                  npm install --no-save @vitest/coverage-v8
+                  npm run test:coverage > webview_coverage.txt 2>&1
+                  cd ..
+                  # Default the encoding to UTF-8 - It's not the default on Windows
+                  PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage webview-ui/webview_coverage.txt --type=webview --github-output --verbose
 
+            # Save coverage reports as artifacts (workflow-scoped)
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
               # Only upload artifacts on Linux - We only need coverage from one OS
@@ -142,21 +130,54 @@ jobs:
               with:
                   name: pr-coverage-reports
                   path: |
-                      coverage-unit/lcov.info
-                      webview-ui/coverage/lcov.info
+                      extension_coverage.txt
+                      webview-ui/webview_coverage.txt
+                  retention-period: workflow # Artifacts are automatically deleted when the workflow completes
 
-    test-platform-integration:
-        needs: quality-checks
+            # Set the check as failed if any of the tests failed
+            - name: Print test results and check for failures
+              run: |
+                  echo "Extension Tests Result: ${{ steps.extension_coverage.outcome }}"
+                  cat extension_coverage.txt
+
+                  echo "Webview Tests Result: ${{ steps.webview_coverage.outcome }}"
+                  cat webview-ui/webview_coverage.txt
+
+                  # Check if any of the test steps failed
+                  # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#steps-context
+                  if [ "${{ steps.extension_coverage.outcome }}" != "success" ] || [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
+                      echo "Tests failed."
+                      exit 1
+                  fi
+
+    coverage:
+        needs: test
         runs-on: ubuntu-latest
+        # Only run on PRs to main branch
+        if: github.event_name == 'pull_request' && github.base_ref == 'main'
         steps:
             - name: Checkout code
               uses: actions/checkout@v4
+              with:
+                  fetch-depth: 0 # Fetch all history for accurate comparison
+
+            # Setup Python for coverage script
+            - name: Setup Python
+              uses: actions/setup-python@v4
+              with:
+                  python-version: "3.10"
+
+            - name: Install Python dependencies
+              run: |
+                  python -m pip install --upgrade pip
+                  pip install requests
 
             - name: Setup Node.js environment
               uses: actions/setup-node@v4
               with:
                   node-version: 22
-                  
+
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
             - name: Cache root dependencies
               uses: actions/cache@v4
               id: root-cache
@@ -164,6 +185,7 @@ jobs:
                   path: node_modules
                   key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
 
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
             - name: Cache webview-ui dependencies
               uses: actions/cache@v4
               id: webview-cache
@@ -171,14 +193,6 @@ jobs:
                   path: webview-ui/node_modules
                   key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
 
-            # Cache testing-platform dependencies
-            - name: Cache testing-platform dependencies
-              uses: actions/cache@v4
-              id: testing-platform-cache
-              with:
-                path: testing-platform/node_modules
-                key: ${{ runner.os }}-npm-testing-platform-${{ hashFiles('testing-platform/package-lock.json') }}
-
             - name: Install root dependencies
               if: steps.root-cache.outputs.cache-hit != 'true'
               run: npm ci
@@ -187,88 +201,30 @@ jobs:
               if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
-            - name: Setup Go
-              uses: actions/setup-go@v5
-              with:
-                  go-version: '1.24'
-                  cache-dependency-path: cli/go.sum
+            # Build the extension before running tests
+            - name: Build Extension
+              run: npm run compile
 
-            - name: Download Node.js binaries
-              run: npm run download-node
-
-            - name: Build CLI binaries
-              run: npm run compile-cli
-
-            - name: Download ripgrep binaries
-              run: npm run download-ripgrep
-
-            - name: Compile standalone CLI
-              run: npm run compile-standalone-cli
-
-            - name: Install testing platform dependencies
-              if: steps.testing-platform-cache.outputs.cache-hit != 'true'
-              run: cd testing-platform && npm ci
-
-            - name: Running testing platform integration spec tests
-              continue-on-error: true
-              timeout-minutes: 7
-              # Temporarily wrapping the test command to always return a neutral exit code.
-              # This prevents the job from showing as failed and avoids distracting developers
-              # until the integration tests are ready to be enforced.
-              run: |
-                npm run test:tp-orchestrator -- tests/specs/ --count=1 --coverage || true
-
-            - name: Save Coverage Reports
-              uses: actions/upload-artifact@v4
-              with:
-                name: test-platform-integration-core-coverage
-                path: coverage/**/lcov.info
-
-    qlty:
-        needs: [test, test-platform-integration]
-        runs-on: ubuntu-latest
-        # Run on PRs to main, pushes to main, and manual dispatches
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v4
-
-            - name: Download unit tests coverage reports
+            # Download coverage artifacts from test job
+            - name: Download Coverage Reports
               uses: actions/download-artifact@v4
               with:
                   name: pr-coverage-reports
-                  path: .
+                  path: . # Download to root directory to match expected paths
 
-            - name: Upload core unit tests coverage to Qlty
-              uses: qltysh/qlty-action/coverage@v2
-              with:
-                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
-                  # we can merge multiple files if necessary
-                  files: |
-                    coverage-unit/lcov.info
-                  tag: unit:core
+            # Process coverage workflow
+            - name: Process coverage workflow
+              id: coverage
+              run: |
+                  # Extract PR number from GITHUB_REF
+                  PR_NUMBER=$(echo "$GITHUB_REF" | sed -e 's/refs\/pull\///' -e 's/\/merge//')
 
-            - name: Upload webview-ui unit tests coverage to Qlty
-              uses: qltysh/qlty-action/coverage@v2
-              with:
-                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
-                  # we can merge multiple files if necessary
-                  files: |
-                    webview-ui/coverage/lcov.info
-                  tag: unit:webview-ui
-                  add-prefix: webview-ui/
-
-            - name: Download test platform integration core coverage artifact
-              uses: actions/download-artifact@v4
-              continue-on-error: true
-              id: download-integration-coverage
-              with:
-                name: test-platform-integration-core-coverage
-                path: integration-core-coverage-reports
-
-            - name: Upload core integration tests coverage to Qlty
-              if: steps.download-integration-coverage.outcome == 'success'
-              uses: qltysh/qlty-action/coverage@v2
-              with:
-                token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
-                files: integration-core-coverage-reports/**/lcov.info
-                tag: integration:core
+                  # Run the coverage workflow from root directory
+                  PYTHONPATH=.github/scripts python -m coverage_check process-workflow \
+                    --base-branch ${{ github.base_ref }} \
+                    --pr-number $PR_NUMBER \
+                    --repo $GITHUB_REPOSITORY \
+                    --token ${{ secrets.GITHUB_TOKEN }} \
+                    --verbose
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/trigger-jetbrains-tests.yml

@@ -1,53 +0,0 @@
-name: Trigger Jetbrains Plugin <-> Cline Tests
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-permissions:
-  contents: read
-concurrency:
-  group: jetbrains-trigger-${{ github.event.number }}
-  cancel-in-progress: true
-
-jobs:
-  trigger-integration-test:
-    name: Run Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Generate GitHub App Token
-        id: app-token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: 1998650
-          private-key: ${{ secrets.CLINE_JETBRAINS_WORKFLOW_KEY }}
-          owner: cline
-          repositories: intellij-plugin
-
-      - name: Trigger IntelliJ Plugin Integration Test
-        run: |
-          curl -X POST \
-            -H "Authorization: Bearer ${{ steps.app-token.outputs.token }}" \
-            -H "Accept: application/vnd.github.v3+json" \
-            -H "User-Agent: cline-pr-trigger" \
-            -H "Content-Type: application/json" \
-            https://api.github.com/repos/cline/intellij-plugin/dispatches \
-            -d @- <<EOF
-          {
-            "event_type": "cline-pr-check",
-            "client_payload": {
-              "pr_number": "${{ github.event.number }}",
-              "branch_name": "${{ github.head_ref }}",
-              "action": "${{ github.event.action }}",
-              "sha": "${{ github.event.pull_request.head.sha }}",
-              "pr_title": ${{ toJSON(github.event.pull_request.title) }},
-              "pr_url": "${{ github.event.pull_request.html_url }}"
-            }
-          }
-          EOF
-
-      - name: Log trigger details
-        run: |
-          echo "Triggered IntelliJ Plugin integration test for:"
-          echo "  PR #${{ github.event.number }}: ${{ github.event.pull_request.title }}"
-          echo "  Branch: ${{ github.head_ref }}"
-          echo "  Action: ${{ github.event.action }}"
-          echo "  SHA: ${{ github.event.pull_request.head.sha }}"

.gitignore

@@ -15,22 +15,20 @@ pnpm-lock.yaml
 .venv
 .actrc
 
-webview-ui/src/**/*.js
-webview-ui/src/**/*.js.map
-
 # Ignore coverage directories and files
 coverage
-coverage-unit
-.nyc_output
 # But don't ignore the coverage scripts in .github/scripts/
 !.github/scripts/coverage/
 
 *evals.env
-.env
 
 ## Generated files ##
 src/generated/
-src/shared/proto/
+src/core/controller/*/methods.ts
+src/core/controller/*/index.ts
+src/core/controller/grpc-service-config.ts
+src/shared/proto/*.ts
+src/shared/proto/host/*.ts
 webview-ui/src/services/grpc-client.ts
 
 # E2E Tests

.husky/pre-commit

@@ -1 +1,17 @@
-lint-staged
+echo "Running pre-commit checks..."
+
+# Run ESLint
+echo "Running ESLint..."
+npm run lint || {
+    echo "❌ ESLint check failed. Please fix the errors and try committing again."
+    exit 1
+}
+
+# Run Prettier
+echo "Running Prettier..."
+npx lint-staged --verbose || {
+     echo "❌ Prettier failed. Please fix the errors and try committing again."
+     exit 1
+ }
+
+echo "✅ All checks passed!"

.mocharc.json

@@ -1,15 +1,6 @@
 {
-	"extension": [
-		"ts"
-	],
-	"spec": [
-		"src/**/__tests__/*.ts"
-	],
-	"require": [
-		"ts-node/register",
-		"source-map-support/register",
-		"./src/test/requires.ts"
-	],
-	"recursive": true,
-	"exit": true
+	"extension": ["ts"],
+	"spec": ["src/**/__tests__/*.ts", "eslint-rules/__tests__/**/*.test.ts"],
+	"require": ["ts-node/register", "source-map-support/register", "./src/test/requires.ts"],
+	"recursive": true
 }

.nycrc.unit.json

@@ -1,48 +0,0 @@
-{
-	"all": true,
-	"check-coverage": false,
-	"reporter": [
-		"text",
-		"lcov"
-	],
-	"include": [
-		"src/**/*.ts"
-	],
-	"exclude": [
-		"**/*.d.ts",
-
-		"**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs}",
-		"**/__tests__/**",
-		"**/test/**",
-		"**/tests/**",
-		"**/.nyc_output/**",
-		"**/.vscode-test/**",
-		"**/tests-results/**",
-		"src/test/**",
-
-		"src/generated/**",
-
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/out/**",
-		"**/build/**",
-		"**/coverage/**",
-		"**/coverage-unit/**",
-		"**/proto/**",
-
-		"**/*.{config,setup}.{js,ts,mjs,cjs}",
-		"**/vite-env.d.ts",
-
-		"**/*.{css,scss,sass,less,styl}",
-		"**/*.{svg,png,jpg,jpeg,gif,ico}",
-		"**/*.{json,yaml,yml}"
-	],
-	"extension": [
-		".ts",
-		".js"
-	],
-	"cache": true,
-	"sourceMap": true,
-	"instrument": true,
-	"report-dir": "./coverage-unit"
-}

.prettierignore

@@ -0,0 +1,10 @@
+dist/
+node_modules
+webview-ui/build/
+*.md
+package-lock.json
+src/core/prompts/system.ts
+src/core/prompts/model_prompts/claude4.ts
+evals/
+docs/
+out/

.prettierrc.json

@@ -0,0 +1,8 @@
+{
+	"tabWidth": 4,
+	"useTabs": true,
+	"printWidth": 130,
+	"semi": false,
+	"bracketSameLine": true,
+	"endOfLine": "lf"
+}

.vscode/extensions.json

@@ -2,9 +2,9 @@
 	// See http://go.microsoft.com/fwlink/?LinkId=827846
 	// for the documentation about the extensions.json format
 	"recommendations": [
+		"dbaeumer.vscode-eslint",
 		"connor4312.esbuild-problem-matchers",
 		"ms-vscode.extension-test-runner",
-		"bradlc.vscode-tailwindcss",
-		"biomejs.biome"
+		"bradlc.vscode-tailwindcss"
 	]
 }

.vscode/launch.json

@@ -6,68 +6,21 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension (production)",
+			"name": "Run Extension",
 			"type": "extensionHost",
 			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"--disable-extensions", // Avoid conflicts with installed extensions
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "${defaultBuildTask}",
-			"envFile": "${workspaceFolder}/.env",
 			"env": {
 				"IS_DEV": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				// Use the environment variable to determine the backend URL
+				// Options: "production", "staging", "local"
+				// Require the extension to reload to apply changes
 				"CLINE_ENVIRONMENT": "production"
 			}
 		},
-		{
-			"name": "Run Extension (staging)",
-			"type": "extensionHost",
-			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"--disable-extensions", // Avoid conflicts with installed extensions
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}",
-			"envFile": "${workspaceFolder}/.env",
-			"env": {
-				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "staging"
-			}
-		},
-		{
-			"name": "Run Extension (local)",
-			"type": "extensionHost",
-			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--disable-workspace-trust",
-				"--disable-extensions", // Avoid conflicts with installed extensions
-				"${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}",
-			"envFile": "${workspaceFolder}/.env",
-			"env": {
-				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				"CLINE_ENVIRONMENT": "local"
-			}
-		},
 		{
 			"name": "Run Extension (Fresh Install Mode)",
 			"type": "extensionHost",
@@ -77,17 +30,14 @@
 				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
 				"--sync=off",
-				"--disable-extensions", // Avoid conflicts with installed extensions
+				"--disable-extensions",
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js"
-			],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "clean-tmp-user",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
-			"envFile": "${workspaceFolder}/.env",
 			"env": {
 				"IS_DEV": "true",
 				"TEMP_PROFILE": "true",
@@ -98,73 +48,22 @@
 		{
 			"type": "node",
 			"request": "launch",
-			"name": "Debug Test Standalone Core Api Server (test:sca-server)",
-			"skipFiles": [
-				"<node_internals>/**"
-			],
+			"name": "Run Standalone Service",
+			"skipFiles": ["<node_internals>/**"],
 			"sourceMaps": true,
-			"resolveSourceMapLocations": [
-				"${workspaceFolder}/**",
-				"!**/node_modules/**"
-			],
-			"cwd": "${workspaceFolder}",
-			"outFiles": [
-				"${workspaceFolder}/dist/**/*.js",
-				"${workspaceFolder}/dist-standalone/**/*.js"
-			],
+			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
+			"cwd": "${workspaceFolder}/dist-standalone",
+			"outFiles": ["${workspaceFolder}/dist-standalone/**/*.js"],
 			"preLaunchTask": "compile-standalone",
-			"runtimeExecutable": "npx",
-			"runtimeArgs": [
-				"tsx"
-			],
-			"program": "scripts/test-standalone-core-api-server.ts",
-			"envFile": "${workspaceFolder}/.env",
 			"env": {
-				"PROTOBUS_PORT": "26040",
-				"HOSTBRIDGE_PORT": "26041",
-				"WORKSPACE_DIR": "${workspaceFolder}",
-				"E2E_TEST": "true",
-				"CLINE_ENVIRONMENT": "local"
+				// Turns on grpc debug log.
+				//"GRPC_TRACE": "all",
+				//"GRPC_VERBOSITY": "DEBUG",
+				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules",
+
+				"HOST_BRIDGE_ADDRESS": "localhost:50052"
 			},
-			"console": "integratedTerminal",
-			"internalConsoleOptions": "neverOpen"
-		},
-		{
-			"type": "node",
-			"request": "launch",
-			"name": "Debug Current Test File",
-			"skipFiles": [
-				"<node_internals>/**"
-			],
-			"sourceMaps": true,
-			"resolveSourceMapLocations": [
-				"${workspaceFolder}/**",
-				"!**/node_modules/**"
-			],
-			"cwd": "${workspaceFolder}",
-			"runtimeExecutable": "npx",
-			"runtimeArgs": [
-				"mocha"
-			],
-			"args": [
-				"--require",
-				"ts-node/register",
-				"--require",
-				"source-map-support/register",
-				"--require",
-				"./src/test/requires.ts",
-				"--exit",
-				"${file}"
-			],
-			"envFile": "${workspaceFolder}/.env",
-			"env": {
-				"TS_NODE_PROJECT": "./tsconfig.unit-test.json",
-				"NODE_ENV": "test",
-				"IS_DEV": "true",
-				"CLINE_ENVIRONMENT": "local"
-			},
-			"console": "integratedTerminal",
-			"internalConsoleOptions": "openOnSessionStart"
+			"program": "standalone.js"
 		}
 	]
 }

.vscode/settings.json

@@ -6,26 +6,8 @@
 	},
 	"search.exclude": {
 		"out": true, // set this to false to include "out" folder in search results
-		"dist": true, // set this to false to include "dist" folder in search results,
-		"node_modules": true,
-		"dist-standalone": true
+		"dist": true // set this to false to include "dist" folder in search results
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off",
-	"typescript.preferences.quoteStyle": "double",
-	// Protobuf settings
-	"protoc": {
-		"options": [
-			"--proto_path=proto"
-		]
-	},
-	// Enable Lint and format using Biome
-	"biome.enabled": true,
-	"editor.defaultFormatter": "biomejs.biome",
-	"editor.codeActionsOnSave": {
-		"source.fixAll.biome": "explicit",
-		"source.removeUnused.biome": "always",
-		"source.removeUnusedImports": "always",
-		"source.organizeImports.biome": "always"
-	}
+	"typescript.tsc.autoDetect": "off"
 }

.vscode/tasks.json

@@ -30,13 +30,7 @@
 		},
 		{
 			"label": "watch",
-			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview",
-				"npm: dev:webview",
-				"npm: watch:tsc",
-				"npm: watch:esbuild"
-			],
+			"dependsOn": ["npm: protos", "npm: build:webview", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild"],
 			"presentation": {
 				"reveal": "always"
 			},
@@ -66,9 +60,7 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -86,9 +78,7 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview:test",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -123,9 +113,7 @@
 			],
 			"isBackground": true,
 			"label": "npm: dev:webview",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -161,9 +149,7 @@
 			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -199,9 +185,7 @@
 			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -220,9 +204,7 @@
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"label": "npm: watch:tsc",
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -233,9 +215,7 @@
 			"script": "watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
-			"dependsOn": [
-				"npm: protos"
-			],
+			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"reveal": "always",
 				"group": "watchers"
@@ -244,11 +224,7 @@
 		},
 		{
 			"label": "tasks: watch-tests",
-			"dependsOn": [
-				"npm: protos",
-				"npm: watch",
-				"npm: watch-tests"
-			],
+			"dependsOn": ["npm: protos", "npm: watch", "npm: watch-tests"],
 			"problemMatcher": []
 		},
 		{
@@ -259,9 +235,7 @@
 		{
 			"label": "clean-tmp-user",
 			"type": "shell",
-			"dependsOn": [
-				"watch"
-			],
+			"dependsOn": ["watch"],
 			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
 		}
 	],

.vscodeignore

@@ -18,7 +18,6 @@ tsconfig*.json
 eslint-rules/**
 .github/**
 .husky/**
-.env
 
 # Custom
 **/demo.gif
@@ -62,12 +61,6 @@ old_docs/**
 !assets/icons/**
 
 # Ignore E2E build files
-e2e-build.mjs
+e2e-build.js
 e2e.vsix
 test-results/
-
-# Ignore Storybook files
-**/*.stories.tsx
-*storybook.log
-storybook-static
-**/StorybookDecorator.tsx

CONTRIBUTING.md

@@ -14,11 +14,14 @@ Bug reports help make Cline better for everyone! Before creating a new issue, pl
 ## Before Contributing
 
 All contributions must begin with a GitHub Issue, unless the change is for small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality.
-**For features and contributions**:
-- First check the [Feature Requests discussions board](https://github.com/cline/cline/discussions/categories/feature-requests) for similar ideas
-- If your idea is new, create a new feature request  
-- Wait for approval from core maintainers before starting implementation
-- Once approved, feel free to begin working on a PR with the help of our community!
+
+- **Check existing issues**: Search [GitHub Issues](https://github.com/cline/cline/issues).
+- **Create an issue**: Use appropriate templates:
+    - **Contributions:** Use the "Contribution Request" template to propose what you'd like to work on.
+    - **Bugs:** "Bug Report" template for reporting issues.
+    - **Features:** "Detailed Feature Proposal" template for suggesting new features.
+- **Wait for approval**: A core Cline contributor must approve your contribution request before you start implementation.
+- **Claim issues**: Once approved, the issue will be assigned to you.
 
 **PRs without approved issues may be closed.**
 
@@ -74,6 +77,7 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 4. Testing
     - Run `npm run test` to run tests locally. 
     - Before submitting PR, run `npm run format:fix` to format your code
+    - Run `npm run test:ci` to run tests locally
 
 ### Extension
 
@@ -146,7 +150,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     - Run `npm run lint` to check code style
     - Run `npm run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
-    - Address any warnings or errors from linter before submitting
+    - Address any ESLint warnings or errors before submitting
     - Follow TypeScript best practices and maintain type safety
 
 3. **Testing**
@@ -156,36 +160,6 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     - Update existing tests if your changes affect them
     - Include both unit tests and integration tests where appropriate
 
-    **End-to-End (E2E) Testing**
-    
-    Cline includes comprehensive E2E tests using Playwright that simulate real user interactions with the extension in VS Code:
-    
-    - **Running E2E tests:**
-      ```bash
-      npm run test:e2e        # Build and run all E2E tests
-      npm run e2e             # Run tests without rebuilding
-      npm run test:e2e -- --debug  # Run with interactive debugger
-      ```
-    
-    - **Writing E2E tests:**
-      - Tests are located in `src/test/e2e/`
-      - Use the `e2e` fixture for single-root workspace tests
-      - Use `e2eMultiRoot` fixture for multi-root workspace tests
-      - Follow existing patterns in `auth.test.ts`, `chat.test.ts`, `diff.test.ts`, and `editor.test.ts`
-      - See `src/test/e2e/README.md` for detailed documentation
-    
-    - **Debug mode features:**
-      - Interactive Playwright Inspector for step-by-step debugging
-      - Record new interactions and generate test code automatically
-      - Visual VS Code instance for manual testing
-      - Element inspection and selector validation
-    
-    - **Test environment:**
-      - Automated VS Code setup with Cline extension loaded
-      - Mock API server for backend testing
-      - Temporary workspaces with test fixtures
-      - Video recording for failed tests
-
 4. **Version Management with Changesets**
 
     - Create a changeset for any user-facing changes using `npm run changeset`

README.md

@@ -30,9 +30,9 @@ English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md
 </table>
 </div>
 
-Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
+Meet Cline (pronounced /klaɪn/, like "Klein"), an AI assistant that can use your **CLI** a**N**d **E**ditor.
 
-Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
+Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
 
 1. Enter your task and add images to convert mockups into functional apps or fix bugs with screenshots.
 2. Cline starts by analyzing your file structure & source code ASTs, running regex searches, and reading relevant files to get up to speed in existing projects. By carefully managing what information is added to context, Cline can provide valuable assistance even for large, complex projects without overwhelming the context window.
@@ -87,7 +87,7 @@ All changes made by Cline are recorded in your file's Timeline, providing an eas
 
 ### Use the Browser
 
-With Claude Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
+With Claude 3.5 Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
 
 Try asking Cline to "test the app", and watch as he runs a command like `npm run dev`, launches your locally running dev server in a browser, and performs a series of tests to confirm that everything works. [See a demo here.](https://x.com/sdrzn/status/1850880547825823989)
 

biome.jsonc

@@ -1,166 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
-	"vcs": {
-		"enabled": true,
-		"clientKind": "git",
-		"useIgnoreFile": true,
-		"defaultBranch": "main"
-	},
-	"assist": {
-		"enabled": true,
-		"actions": {
-			"source": {
-				"organizeImports": "on",
-				"useSortedAttributes": "on"
-			}
-		}
-	},
-	"linter": {
-		"enabled": true,
-		"domains": {
-			"react": "recommended"
-		},
-		// Ideally we would want to turn on all the rules that are currently off,
-		// keeping them off currently to make sure only changes on the migrations
-		// are included in the initial PR before we apply the format and lint changes.
-		// TODO: turn on all rules that are currently off if applicable.
-		// TODO: Remove --diagnostic-level=error from CI commands.
-		"rules": {
-			"recommended": true,
-			"correctness": {
-				"useExhaustiveDependencies": "off",
-				"noUndeclaredVariables": "off",
-				"noEmptyPattern": "off",
-				"useJsxKeyInIterable": "off",
-				"noInnerDeclarations": "off",
-				"useHookAtTopLevel": "off",
-				"useYield": "off",
-				"noConstructorReturn": "off",
-				"noInvalidPositionAtImportRule": "off",
-				"noSwitchDeclarations": "off",
-				"noUnusedImports": "error"
-			},
-			"a11y": "off",
-			"style": {
-				"useNodejsImportProtocol": "off",
-				"useImportType": "off",
-				"useBlockStatements": "warn",
-				"useNamingConvention": "off",
-				"useThrowOnlyError": "info",
-				"useConsistentArrayType": "off",
-				"noParameterAssign": "off",
-				"useAsConstAssertion": "off",
-				"useDefaultParameterLast": "off",
-				"noNonNullAssertion": "off",
-				"useEnumInitializers": "off",
-				"useSelfClosingElements": "off",
-				"useSingleVarDeclarator": "off",
-				"useNumberNamespace": "off",
-				"noInferrableTypes": "off",
-				"useTemplate": "off",
-				"noUselessElse": "off"
-			},
-			"suspicious": {
-				"noDoubleEquals": "warn",
-				"noImplicitAnyLet": "info",
-				"noThenProperty": "off",
-				"noAsyncPromiseExecutor": "off",
-				"noImportAssign": "off",
-				"noExplicitAny": "off",
-				"noControlCharactersInRegex": "off",
-				"noShadowRestrictedNames": "off",
-				"noArrayIndexKey": "info",
-				"noAssignInExpressions": "info"
-			},
-			"complexity": {
-				"noUselessConstructor": "off",
-				"useOptionalChain": "off",
-				"noBannedTypes": "off",
-				"useLiteralKeys": "off",
-				"noUselessCatch": "off",
-				"noUselessSwitchCase": "off",
-				"noStaticOnlyClass": "off"
-			},
-			"security": {
-				"noDangerouslySetInnerHtml": "info"
-			}
-		}
-	},
-	"formatter": {
-		"enabled": true,
-		"indentStyle": "tab",
-		"indentWidth": 4,
-		"lineWidth": 130,
-		"lineEnding": "lf",
-		"formatWithErrors": true
-	},
-	"javascript": {
-		"formatter": {
-			"semicolons": "asNeeded",
-			"arrowParentheses": "always",
-			"bracketSameLine": true,
-			"bracketSpacing": true,
-			"jsxQuoteStyle": "double",
-			"quoteProperties": "asNeeded",
-			"trailingCommas": "all"
-		}
-	},
-	"json": {
-		"formatter": {
-			"trailingCommas": "none",
-			"expand": "always"
-		}
-	},
-	"files": {
-		"includes": [
-			"**",
-			"!**/dist",
-			"!**/dist-*",
-			"!**/out",
-			"!**/evals",
-			"!**/playwright",
-			"!**/test-results",
-			"!**/node_modules",
-			"!**/webview-ui/build",
-			"!**/generated",
-			"!**/proto",
-			"!**/tests/specs"
-		]
-	},
-	"plugins": [
-		"src/dev/grit/process-env.grit"
-	],
-	"overrides": [
-		{
-			"includes": [
-				"**",
-				"!**/hosts/vscode/**",
-				"!**/test/**",
-				"!**/*.test.ts",
-				"!src/dev/**",
-				"!src/extension.ts",
-				"!src/integrations/git/commit-message-generator.ts",
-				"!src/integrations/terminal/**",
-				"!src/core/controller/ui/openWalkthrough.ts"
-			],
-			"plugins": [
-				"src/dev/grit/vscode-api.grit"
-			]
-		},
-		{
-			"includes": [
-				"**",
-				"!src/core/storage/state-migrations.ts",
-				"!src/core/storage/FileContextTracker.ts",
-				"!src/core/context/context-tracking/FileContextTracker.ts",
-				"!src/common.ts",
-				"!src/services/logging/distinctId.ts",
-				"!src/core/storage/utils/state-helpers.ts",
-				"!src/extension.ts"
-			],
-			"plugins": [
-				"src/dev/grit/use-cache-service.grit"
-			]
-		}
-	]
-}

buf.yaml

@@ -9,6 +9,7 @@ lint:
 
     except: # Add exceptions for current patterns that contradict STANDARD settings
         - RPC_PASCAL_CASE # rpcs are camel case (start with lowercase)
+        - PACKAGE_DIRECTORY_MATCH # the protos in the cline package are not in a dir named cline.
         - RPC_REQUEST_RESPONSE_UNIQUE # request messages are not unique.
         - RPC_REQUEST_STANDARD_NAME # request messages dont all end with Request
         - RPC_RESPONSE_STANDARD_NAME # response messages dont all end with Response

cli/.gitignore

@@ -1,2 +0,0 @@
-cline-core-debug.log
-bin/*

cli/cline-text-logo.txt

@@ -1,6 +0,0 @@
-/_____/\ /_/\      /_______/\/__/\ /__/\ /_____/\     
-\:::__\/ \:\ \     \__.::._\/\::\_\\  \ \\::::_\/_    
- \:\ \  __\:\ \       \::\ \  \:. `-\  \ \\:\/___/\   
-  \:\ \/_/\\:\ \____  _\::\ \__\:. _    \ \\::___\/_  
-   \:\_\ \ \\:\/___/\/__\::\__/\\. \`-\  \ \\:\____/\ 
-    \_____\/ \_____\/\________\/ \__\/ \__\/ \_____\/ 

cli/cmd/cline-host/main.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/spf13/cobra"
-
-	"github.com/cline/cli/pkg/hostbridge"
-)
-
-var (
-	port    int
-	verbose bool
-)
-
-func main() {
-	rootCmd := &cobra.Command{
-		Use:   "cline-host",
-		Short: "Cline Host Bridge Service",
-		Long:  `A simple host bridge service that provides host operations for Cline Core.`,
-		RunE:  runServer,
-	}
-
-	rootCmd.Flags().IntVarP(&port, "port", "p", 51052, "port to listen on")
-	rootCmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "verbose logging")
-
-	if err := rootCmd.Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func runServer(cmd *cobra.Command, args []string) error {
-	ctx := cmd.Context()
-
-	// Create gRPC hostbridge service
-	service := hostbridge.NewGrpcServer(port, verbose)
-
-	// Handle graceful shutdown
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	go func() {
-		sigChan := make(chan os.Signal, 1)
-		signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-		<-sigChan
-
-		if verbose {
-			log.Println("Shutting down hostbridge server...")
-		}
-
-		cancel()
-	}()
-
-	// Start server
-	if verbose {
-		log.Printf("Starting Cline Host Bridge on port %d", port)
-	}
-
-	// Run the service
-	if err := service.Start(ctx); err != nil {
-		return fmt.Errorf("failed to run service: %w", err)
-	}
-
-	return nil
-}

cli/cmd/cline/main.go

@@ -1,228 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli"
-	"github.com/cline/cli/pkg/cli/auth"
-	"github.com/cline/cli/pkg/cli/display"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/cline"
-	"github.com/spf13/cobra"
-)
-
-var (
-	coreAddress  string
-	verbose      bool
-	outputFormat string
-
-	// Task creation flags (for root command)
-	images     []string
-	files      []string
-	workspaces []string
-	mode       string
-	settings   []string
-	yolo       bool
-)
-
-func main() {
-	rootCmd := &cobra.Command{
-		Use:   "cline [prompt]",
-		Short: "Cline CLI - AI-powered coding assistant",
-		Long: `A command-line interface for interacting with Cline AI coding assistant.
-
-Start a new task by providing a prompt:
-  cline "Create a new Python script that prints hello world"
-
-Or run with no arguments to enter interactive mode:
-  cline
-
-This CLI also provides task management, configuration, and monitoring capabilities.`,
-		Args: cobra.ArbitraryArgs,
-		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			if outputFormat != "rich" && outputFormat != "json" && outputFormat != "plain" {
-				return fmt.Errorf("invalid output format '%s': must be one of 'rich', 'json', or 'plain'", outputFormat)
-			}
-
-			return global.InitializeGlobalConfig(&global.GlobalConfig{
-				Verbose:      verbose,
-				OutputFormat: outputFormat,
-				CoreAddress:  coreAddress,
-			})
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			var instanceAddress string
-
-			// If --address flag not provided, start instance BEFORE getting prompt
-			if !cmd.Flags().Changed("address") {
-				if global.Config.Verbose {
-					fmt.Println("Starting new Cline instance...")
-				}
-				instance, err := global.Clients.StartNewInstance(ctx)
-				if err != nil {
-					return fmt.Errorf("failed to start new instance: %w", err)
-				}
-				instanceAddress = instance.Address
-				if global.Config.Verbose {
-					fmt.Printf("Started instance at %s\n\n", instanceAddress)
-				}
-
-				// Set up cleanup on exit
-				defer func() {
-					if global.Config.Verbose {
-						fmt.Println("\nCleaning up instance...")
-					}
-					registry := global.Clients.GetRegistry()
-					if err := global.KillInstanceByAddress(context.Background(), registry, instanceAddress); err != nil {
-						if global.Config.Verbose {
-							fmt.Printf("Warning: Failed to clean up instance: %v\n", err)
-						}
-					}
-				}()
-
-				// Check if user has credentials configured
-				if !isUserReadyToUse(ctx, instanceAddress) {
-					// Create renderer for welcome messages
-					renderer := display.NewRenderer(global.Config.OutputFormat)
-
-					markdown := "## hey there! looks like you're new here. let's get you set up"
-					rendered := renderer.RenderMarkdown(markdown)
-					fmt.Printf("\n%s\n\n", rendered)
-
-					if err := auth.HandleAuthMenuNoArgs(ctx); err != nil {
-						return fmt.Errorf("auth setup failed: %w", err)
-					}
-
-					// Re-check after auth wizard
-					if !isUserReadyToUse(ctx, instanceAddress) {
-						return fmt.Errorf("credentials still not configured - please run 'cline auth' to complete setup")
-					}
-
-					markdown = "## ✓ setup complete, you can now use the cline cli"
-					rendered = renderer.RenderMarkdown(markdown)
-					fmt.Printf("\n%s\n\n", rendered)
-				}
-			} else {
-				// User specified --address flag, use that
-				instanceAddress = coreAddress
-			}
-
-			var prompt string
-
-			// If args provided, use as prompt
-			if len(args) > 0 {
-				prompt = strings.Join(args, " ")
-			} else {
-				// Show interactive input to get prompt
-				var err error
-				prompt, err = promptForInitialTask()
-				if err != nil {
-					return err
-				}
-				if prompt == "" {
-					return fmt.Errorf("prompt required")
-				}
-			}
-
-			return cli.CreateAndFollowTask(ctx, prompt, cli.TaskOptions{
-				Images:     images,
-				Files:      files,
-				Workspaces: workspaces,
-				Mode:       mode,
-				Settings:   settings,
-				Yolo:       yolo,
-				Address:    instanceAddress,
-			})
-		},
-	}
-
-	rootCmd.PersistentFlags().StringVar(&coreAddress, "address", fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT), "Cline Core gRPC address")
-	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose output")
-	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "rich", "output format (rich|json|plain)")
-
-	// Task creation flags (only apply when using root command with prompt)
-	rootCmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
-	rootCmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	rootCmd.Flags().StringSliceVarP(&workspaces, "workdir", "w", nil, "workdir directory paths")
-	rootCmd.Flags().StringVarP(&mode, "mode", "m", "plan", "mode (act|plan) - defaults to plan")
-	rootCmd.Flags().StringSliceVarP(&settings, "setting", "s", nil, "task settings (key=value format)")
-	rootCmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
-
-	rootCmd.AddCommand(cli.NewTaskCommand())
-	rootCmd.AddCommand(cli.NewInstanceCommand())
-	rootCmd.AddCommand(cli.NewConfigCommand())
-	rootCmd.AddCommand(cli.NewVersionCommand())
-	rootCmd.AddCommand(cli.NewAuthCommand())
-	rootCmd.AddCommand(cli.NewTaskSendCommand())
-	rootCmd.AddCommand(cli.NewLogsCommand())
-
-	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
-		os.Exit(1)
-	}
-}
-
-func promptForInitialTask() (string, error) {
-	var prompt string
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewText().
-				Title("Start a new Cline task").
-				Description("What would you like Cline to help you with?").
-				Placeholder("e.g., Create a REST API with authentication...").
-				Lines(5).
-				Value(&prompt),
-		),
-	)
-
-	err := form.Run()
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(prompt), nil
-}
-
-// isUserReadyToUse checks if the user has completed initial setup
-// Returns true if welcomeViewCompleted flag is set OR user is authenticated
-// Matches extension logic: welcomeViewCompleted = Boolean(globalState.welcomeViewCompleted || user?.uid)
-func isUserReadyToUse(ctx context.Context, instanceAddress string) bool {
-	manager, err := cli.NewTaskManagerForAddress(ctx, instanceAddress)
-	if err != nil {
-		return false
-	}
-
-	// Get state
-	state, err := manager.GetClient().State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return false
-	}
-
-	// Parse state JSON
-	stateMap := make(map[string]interface{})
-	if err := json.Unmarshal([]byte(state.StateJson), &stateMap); err != nil {
-		return false
-	}
-
-	// Check 1: welcomeViewCompleted flag
-	if welcomeCompleted, ok := stateMap["welcomeViewCompleted"].(bool); ok && welcomeCompleted {
-		return true
-	}
-
-	// Check 2: Is user authenticated? (matches extension's || user?.uid check)
-	if userInfo, ok := stateMap["userInfo"].(map[string]interface{}); ok {
-		if uid, ok := userInfo["uid"].(string); ok && uid != "" {
-			return true
-		}
-	}
-
-	return false
-}

cli/e2e/default_update_test.go

@@ -1,154 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-
-	"github.com/cline/cli/pkg/common"
-)
-
-// 2. Multi-instance start: default_instance remains the first started.
-func TestMultiInstanceDefaultUnchanged(t *testing.T) {
-	_ = setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start first instance and wait healthy
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out1 := listInstancesJSON(ctx, t)
-	if len(out1.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out1.CoreInstances))
-	}
-	firstAddr := out1.CoreInstances[0].Address
-	waitForAddressHealthy(t, firstAddr, defaultTimeout)
-
-	// Start second instance
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out2 := listInstancesJSON(ctx, t)
-	if len(out2.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out2.CoreInstances))
-	}
-
-	// Default should remain the first started address
-	if out2.DefaultInstance != firstAddr {
-		t.Fatalf("default changed; expected %s, got %s", firstAddr, out2.DefaultInstance)
-	}
-}
-
-// 6. Default.json update after removal of current default
-func TestDefaultJsonUpdateAfterRemoval(t *testing.T) {
-	_ = setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start two instances
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out.CoreInstances))
-	}
-
-	// Choose second as new default
-	target := out.CoreInstances[1]
-	waitForAddressHealthy(t, target.Address, defaultTimeout)
-
-	// Set as default
-	_ = mustRunCLI(ctx, t, "instance", "use", target.Address)
-
-	// Verify default switched
-	out = listInstancesJSON(ctx, t)
-	if out.DefaultInstance != target.Address {
-		t.Fatalf("default_instance not updated to %s (got %s)", target.Address, out.DefaultInstance)
-	}
-
-	// Kill the default instance using runtime PID discovery
-	corePID := getCorePID(t, target.Address)
-	if corePID <= 0 {
-		t.Fatalf("could not find PID for core process at %s", target.Address)
-	}
-	t.Logf("Killing cline-core process PID %d for instance %s", corePID, target.Address)
-	if err := syscall.Kill(corePID, syscall.SIGKILL); err != nil {
-		t.Fatalf("kill pid %d: %v", corePID, err)
-	}
-
-	// Wait for removal
-	waitForAddressRemoved(t, target.Address, longTimeout)
-
-	// Clean up dangling host process (SIGKILL leaves these behind by design)
-	t.Logf("Cleaning up dangling host process on port %d", target.HostPort())
-	findAndKillHostProcess(t, target.HostPort())
-
-	// Ensure default_instance updated to another available instance (or removed if none remain)
-	out = listInstancesJSON(ctx, t)
-
-	// If there are instances left, default_instance must be one of them
-	if len(out.CoreInstances) > 0 {
-		found := false
-		for _, it := range out.CoreInstances {
-			if out.DefaultInstance == it.Address {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Fatalf("default_instance %s not set to an existing instance after removal", out.DefaultInstance)
-		}
-	} else {
-		// No instances remain; cli-default-instance.json should be removed
-		clineDir := getClineDir(t)
-		defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-		if _, err := os.Stat(defPath); err == nil {
-			t.Fatalf("expected cli-default-instance.json removed when no instances remain")
-		}
-	}
-
-	// Also verify cli-default-instance.json on disk reflects the in-memory default (if any)
-	clineDir := getClineDir(t)
-	defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-	if len(out.CoreInstances) > 0 {
-		raw, err := os.ReadFile(defPath)
-		if err != nil {
-			t.Fatalf("read cli-default-instance.json: %v", err)
-		}
-		var tmp struct {
-			DefaultInstance string `json:"default_instance"`
-		}
-		if err := json.Unmarshal(raw, &tmp); err != nil {
-			t.Fatalf("unmarshal cli-default-instance.json: %v", err)
-		}
-		if tmp.DefaultInstance != out.DefaultInstance {
-			t.Fatalf("cli-default-instance.json mismatch: file=%s list=%s", tmp.DefaultInstance, out.DefaultInstance)
-		}
-	}
-}
-
-// 11. SQLite database missing (edge): list succeeds and returns empty set
-func TestRegistryDirMissingEdge(t *testing.T) {
-	clineDir := setTempClineDir(t)
-
-	// Remove the settings directory entirely (which contains locks.db)
-	settingsDir := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER)
-	if err := os.RemoveAll(settingsDir); err != nil {
-		t.Fatalf("RemoveAll(%s): %v", common.SETTINGS_SUBFOLDER, err)
-	}
-
-	// Listing should succeed and return empty results
-	ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
-	defer cancel()
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) != 0 {
-		t.Fatalf("expected 0 instances after removing %s dir, got %d", common.SETTINGS_SUBFOLDER, len(out.CoreInstances))
-	}
-
-	// Ensure cli-default-instance.json not present
-	defPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-	if _, err := os.Stat(defPath); err == nil {
-		t.Fatalf("expected no cli-default-instance.json after removing %s dir", common.SETTINGS_SUBFOLDER)
-	}
-}

cli/e2e/helpers_test.go

@@ -1,378 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/cline"
-)
-
-const (
-	defaultTimeout  = 30 * time.Second
-	longTimeout     = 60 * time.Second
-	pollInterval    = 250 * time.Millisecond
-	instancesBinRel = "../bin/cline"
-)
-
-func repoAwareBinPath(t *testing.T) string {
-	// Tests live in repoRoot/cli/e2e. Binary is at repoRoot/cli/bin/cline
-	t.Helper()
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("Getwd error: %v", err)
-	}
-	// cli/e2e -> cli/bin/cline
-	p := filepath.Clean(filepath.Join(wd, instancesBinRel))
-	if _, err := os.Stat(p); err != nil {
-		t.Fatalf("CLI binary not found at %s; run `npm run compile-cli` first: %v", p, err)
-	}
-	return p
-}
-
-func setTempClineDir(t *testing.T) string {
-	t.Helper()
-	dir := t.TempDir()
-	clineDir := filepath.Join(dir, ".cline")
-	if err := os.MkdirAll(clineDir, 0o755); err != nil {
-		t.Fatalf("mkdir clineDir: %v", err)
-	}
-	t.Setenv("CLINE_DIR", clineDir)
-	return clineDir
-}
-
-func runCLI(ctx context.Context, t *testing.T, args ...string) (string, string, int) {
-	t.Helper()
-	bin := repoAwareBinPath(t)
-
-	// Ensure CLI uses the same CLINE_DIR as the tests by passing --config=<CLINE_DIR>
-	// (InitializeGlobalConfig uses ConfigPath as the base directory for registry.)
-	if clineDir := os.Getenv("CLINE_DIR"); clineDir != "" && !contains(args, "--config") {
-		// Prepend persistent flag so Cobra sees it regardless of subcommand position
-		args = append([]string{"--config", clineDir}, args...)
-	}
-
-	cmd := exec.CommandContext(ctx, bin, args...)
-	// Run CLI from repo root so relative paths inside CLI (./cli/bin/...) resolve
-	if wd, err := os.Getwd(); err == nil {
-		repoRoot := filepath.Clean(filepath.Join(wd, "..", ".."))
-		cmd.Dir = repoRoot
-	}
-	// propagate env including CLINE_DIR
-	cmd.Env = os.Environ()
-	outB, errB := &strings.Builder{}, &strings.Builder{}
-	cmd.Stdout = outB
-	cmd.Stderr = errB
-	err := cmd.Run()
-	exit := 0
-	if err != nil {
-		// Extract exit code if possible
-		if ee, ok := err.(*exec.ExitError); ok {
-			exit = ee.ExitCode()
-		} else {
-			exit = -1
-		}
-	}
-	return outB.String(), errB.String(), exit
-}
-
-func mustRunCLI(ctx context.Context, t *testing.T, args ...string) string {
-	t.Helper()
-	out, errOut, exit := runCLI(ctx, t, args...)
-	if exit != 0 {
-		t.Fatalf("cline %v failed (exit=%d)\nstdout:\n%s\nstderr:\n%s", args, exit, out, errOut)
-	}
-	return out
-}
-
-func listInstancesJSON(ctx context.Context, t *testing.T) common.InstancesOutput {
-	t.Helper()
-	// Trigger CLI to perform cleanup/health by invoking list (table output is ignored)
-	_ = mustRunCLI(ctx, t, "instance", "list")
-
-	// Read from SQLite locks database to build structured output
-	clineDir := getClineDir(t)
-
-	// Load default instance from settings file
-	defaultInstance := readDefaultInstanceFromSettings(t, clineDir)
-
-	// Load instances from SQLite
-	instances := readInstancesFromSQLite(t, clineDir)
-
-	return common.InstancesOutput{
-		DefaultInstance: defaultInstance,
-		CoreInstances:   instances,
-	}
-}
-
-func hasAddress(in common.InstancesOutput, addr string) bool {
-	for _, it := range in.CoreInstances {
-		if it.Address == addr {
-			return true
-		}
-	}
-	return false
-}
-
-func getByAddress(in common.InstancesOutput, addr string) (common.CoreInstanceInfo, bool) {
-	for _, it := range in.CoreInstances {
-		if it.Address == addr {
-			return it, true
-		}
-	}
-	return common.CoreInstanceInfo{}, false
-}
-
-func waitFor(t *testing.T, timeout time.Duration, cond func() (bool, string)) {
-	t.Helper()
-	deadline := time.Now().Add(timeout)
-	for {
-		ok, msg := cond()
-		if ok {
-			return
-		}
-		if time.Now().After(deadline) {
-			t.Fatalf("waitFor timeout: %s", msg)
-		}
-		time.Sleep(pollInterval)
-	}
-}
-
-func waitForAddressHealthy(t *testing.T, addr string, timeout time.Duration) {
-	t.Helper()
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	t.Logf("Waiting for gRPC health check on %s...", addr)
-
-	waitFor(t, timeout, func() (bool, string) {
-		if common.IsInstanceHealthy(ctx, addr) {
-			return true, ""
-		}
-		return false, fmt.Sprintf("gRPC health check failed for %s", addr)
-	})
-
-	t.Logf("gRPC health check passed for %s", addr)
-}
-
-func waitForAddressRemoved(t *testing.T, addr string, timeout time.Duration) {
-	t.Helper()
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	waitFor(t, timeout, func() (bool, string) {
-		out := listInstancesJSON(ctx, t)
-		if hasAddress(out, addr) {
-			return false, fmt.Sprintf("address %s still present", addr)
-		}
-		return true, ""
-	})
-}
-
-func findFreePort(t *testing.T) int {
-	t.Helper()
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("listen 127.0.0.1:0: %v", err)
-	}
-	defer l.Close()
-	_, portStr, _ := net.SplitHostPort(l.Addr().String())
-	var port int
-	fmt.Sscanf(portStr, "%d", &port)
-	return port
-}
-
-func getClineDir(t *testing.T) string {
-	t.Helper()
-	clineDir := os.Getenv("CLINE_DIR")
-	if clineDir == "" {
-		t.Fatalf("CLINE_DIR not set")
-	}
-	return clineDir
-}
-
-// isPortInUse checks if a port is currently in use by any process
-func isPortInUse(port int) bool {
-	conn, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-	if err != nil {
-		return true // Port is in use
-	}
-	conn.Close()
-	return false // Port is free
-}
-
-// waitForPortClosed waits for a port to become free (no process listening)
-func waitForPortClosed(t *testing.T, port int, timeout time.Duration) {
-	t.Helper()
-	waitFor(t, timeout, func() (bool, string) {
-		if isPortInUse(port) {
-			return false, fmt.Sprintf("port %d still in use", port)
-		}
-		return true, ""
-	})
-}
-
-// waitForPortsClosed waits for both core and host ports to become free
-func waitForPortsClosed(t *testing.T, corePort, hostPort int, timeout time.Duration) {
-	t.Helper()
-	waitFor(t, timeout, func() (bool, string) {
-		if isPortInUse(corePort) {
-			return false, fmt.Sprintf("core port %d still in use", corePort)
-		}
-		if isPortInUse(hostPort) {
-			return false, fmt.Sprintf("host port %d still in use", hostPort)
-		}
-		return true, ""
-	})
-}
-
-// findAndKillHostProcess finds and kills any process listening on the host port
-// This is used to clean up dangling host processes after SIGKILL tests
-func findAndKillHostProcess(t *testing.T, hostPort int) {
-	t.Helper()
-	// Use lsof to find process listening on the host port
-	cmd := exec.Command("lsof", "-ti", fmt.Sprintf(":%d", hostPort))
-	output, err := cmd.Output()
-	if err != nil {
-		// No process found on port - that's fine
-		return
-	}
-
-	pidStr := strings.TrimSpace(string(output))
-	if pidStr == "" {
-		return
-	}
-
-	var pid int
-	if _, err := fmt.Sscanf(pidStr, "%d", &pid); err != nil {
-		t.Logf("Warning: could not parse PID from lsof output: %s", pidStr)
-		return
-	}
-
-	if pid > 0 {
-		t.Logf("Cleaning up dangling host process PID %d on port %d", pid, hostPort)
-		if err := syscall.Kill(pid, syscall.SIGKILL); err != nil {
-			t.Logf("Warning: failed to kill dangling host process %d: %v", pid, err)
-		}
-	}
-}
-
-// getPIDByPort returns the PID of the process listening on the specified port (fallback method)
-func getPIDByPort(t *testing.T, port int) int {
-	t.Helper()
-	cmd := exec.Command("lsof", "-ti", fmt.Sprintf(":%d", port))
-	output, err := cmd.Output()
-	if err != nil {
-		return 0 // Process not found
-	}
-
-	pidStr := strings.TrimSpace(string(output))
-	if pidStr == "" {
-		return 0
-	}
-
-	pid, err := strconv.Atoi(pidStr)
-	if err != nil {
-		t.Logf("Warning: could not parse PID from lsof output: %s", pidStr)
-		return 0
-	}
-
-	return pid
-}
-
-// getCorePIDViaRPC returns the PID of the cline-core process using RPC (preferred method)
-func getCorePIDViaRPC(t *testing.T, address string) int {
-	t.Helper()
-
-	// Initialize global config to access registry
-	clineDir := os.Getenv("CLINE_DIR")
-	if clineDir == "" {
-		t.Logf("Warning: CLINE_DIR not set, falling back to lsof")
-		return getCorePIDViaLsof(t, address)
-	}
-
-	cfg := &global.GlobalConfig{
-		ConfigPath: clineDir,
-	}
-
-	if err := global.InitializeGlobalConfig(cfg); err != nil {
-		t.Logf("Warning: failed to initialize global config, falling back to lsof: %v", err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	// Get client for the address
-	client, err := global.Clients.GetRegistry().GetClient(ctx, address)
-	if err != nil {
-		t.Logf("Warning: failed to get client for %s, falling back to lsof: %v", address, err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	// Call GetProcessInfo RPC
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		t.Logf("Warning: GetProcessInfo RPC failed for %s, falling back to lsof: %v", address, err)
-		return getCorePIDViaLsof(t, address)
-	}
-
-	return int(processInfo.ProcessId)
-}
-
-// getCorePIDViaLsof returns the PID using lsof (fallback method)
-func getCorePIDViaLsof(t *testing.T, address string) int {
-	t.Helper()
-	_, portStr, err := net.SplitHostPort(address)
-	if err != nil {
-		t.Logf("Warning: invalid address format %s", address)
-		return 0
-	}
-
-	port, err := strconv.Atoi(portStr)
-	if err != nil {
-		t.Logf("Warning: invalid port in address %s", address)
-		return 0
-	}
-
-	return getPIDByPort(t, port)
-}
-
-// getCorePID returns the PID of the cline-core process for the given address
-// Uses RPC first, falls back to lsof if RPC fails
-func getCorePID(t *testing.T, address string) int {
-	t.Helper()
-
-	// Try RPC first (preferred method)
-	if pid := getCorePIDViaRPC(t, address); pid > 0 {
-		return pid
-	}
-
-	// Fall back to lsof if RPC fails
-	return getCorePIDViaLsof(t, address)
-}
-
-// getHostPID returns the PID of the cline-host process for the given host port
-func getHostPID(t *testing.T, hostPort int) int {
-	t.Helper()
-	return getPIDByPort(t, hostPort)
-}
-
-// contains reports whether slice has the target string.
-func contains(slice []string, target string) bool {
-	for _, s := range slice {
-		if s == target {
-			return true
-		}
-	}
-	return false
-}

cli/e2e/main_test.go

@@ -1,47 +0,0 @@
-package e2e
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// TestMain validates required artifacts exist before running E2E tests.
-// It does NOT build artifacts. Build manually via:
-//
-//	npm run compile-standalone
-//	npm run compile-cli
-func TestMain(m *testing.M) {
-	// Determine repo root from cli/e2e
-	wd, err := os.Getwd()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "getwd: %v\n", err)
-		os.Exit(2)
-	}
-	repoRoot := filepath.Clean(filepath.Join(wd, "..", ".."))
-
-	cliBin := filepath.Join(repoRoot, "cli", "bin", "cline")
-	coreJS := filepath.Join(repoRoot, "dist-standalone", "cline-core.js")
-
-	missing := []string{}
-	if _, err := os.Stat(cliBin); err != nil {
-		missing = append(missing, cliBin)
-	}
-	if _, err := os.Stat(coreJS); err != nil {
-		missing = append(missing, coreJS)
-	}
-
-	if len(missing) > 0 {
-		if testing.Short() {
-			// Optional quality-of-life: allow skipping with -short when artifacts are absent
-			fmt.Fprintf(os.Stderr, "[e2e] skipping (-short) due to missing artifacts:\n  %s\n", strings.Join(missing, "\n  "))
-			os.Exit(0)
-		}
-		fmt.Fprintf(os.Stderr, "Missing required build artifacts for E2E tests:\n  %s\n\nPlease build them first:\n  npm run compile-standalone\n  npm run compile-cli\n", strings.Join(missing, "\n  "))
-		os.Exit(2)
-	}
-
-	os.Exit(m.Run())
-}

cli/e2e/mixed_stress_test.go

@@ -1,120 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-
-	"github.com/cline/cli/pkg/common"
-)
-
-// 9. Mixed localhost vs 127.0.0.1 addresses coexist and are both healthy
-func TestMixedLocalhostVs127Coexist(t *testing.T) {
-	clineDir := setTempClineDir(t)
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start one instance
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	// Get the running instance and its port/PID
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) == 0 {
-		t.Fatalf("expected at least 1 instance")
-	}
-	inst := out.CoreInstances[0]
-	waitForAddressHealthy(t, inst.Address, defaultTimeout)
-
-	// Manually add a SQLite entry for the same port but 127.0.0.1 host
-	addr127 := fmt.Sprintf("127.0.0.1:%d", inst.CorePort())
-	dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-
-	if err := insertRemoteInstanceIntoSQLite(t, dbPath, addr127, inst.CorePort(), inst.HostPort()); err != nil {
-		t.Fatalf("insert 127 alias entry: %v", err)
-	}
-
-	// Verify both addresses appear and are healthy
-	waitForAddressHealthy(t, inst.Address, defaultTimeout)
-	waitForAddressHealthy(t, addr127, defaultTimeout)
-
-	out = listInstancesJSON(ctx, t)
-	if !hasAddress(out, inst.Address) || !hasAddress(out, addr127) {
-		t.Fatalf("expected both %s and %s present", inst.Address, addr127)
-	}
-}
-
-// 10. Start-stop stress: loop starting then killing instances; ensure no leftovers
-func TestStartStopStress(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	for i := 0; i < 3; i++ { // keep small for CI time
-		ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-		defer cancel()
-
-		// Snapshot current addresses
-		before := listInstancesJSON(ctx, t)
-		beforeSet := map[string]struct{}{}
-		for _, it := range before.CoreInstances {
-			beforeSet[it.Address] = struct{}{}
-		}
-
-		// Start a new instance
-		_ = mustRunCLI(ctx, t, "instance", "new")
-
-		// Find the new instance address
-		var newAddr string
-		waitFor(t, defaultTimeout, func() (bool, string) {
-			after := listInstancesJSON(ctx, t)
-			for _, it := range after.CoreInstances {
-				if _, ok := beforeSet[it.Address]; !ok {
-					newAddr = it.Address
-					return true, ""
-				}
-			}
-			return false, "new instance address not detected yet"
-		})
-
-		// Wait healthy
-		waitForAddressHealthy(t, newAddr, defaultTimeout)
-
-		// Get PID using runtime discovery and kill it
-		after := listInstancesJSON(ctx, t)
-		info, ok := getByAddress(after, newAddr)
-		if !ok {
-			t.Fatalf("new instance %s missing", newAddr)
-		}
-
-		// Get PID using runtime discovery
-		corePID := getCorePID(t, info.Address)
-		if corePID <= 0 {
-			t.Fatalf("could not find PID for new instance at %s", info.Address)
-		}
-
-		t.Logf("Killing new instance %s (PID %d) for iteration %d", info.Address, corePID, i)
-		if err := syscall.Kill(corePID, syscall.SIGKILL); err != nil {
-			t.Fatalf("kill pid %d: %v", corePID, err)
-		}
-
-		// Wait removed from SQLite database
-		waitForAddressRemoved(t, newAddr, longTimeout)
-
-		// Verify instance is removed from SQLite database
-		clineDir := os.Getenv("CLINE_DIR")
-		if clineDir != "" {
-			dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-			if verifyInstanceExistsInSQLite(t, dbPath, newAddr) {
-				t.Fatalf("expected instance removed from SQLite database: %s", newAddr)
-			}
-		}
-
-		// Clean up dangling host process (SIGKILL leaves these behind by design)
-		t.Logf("Cleaning up dangling host process on port %d for iteration %d", info.HostPort(), i)
-		findAndKillHostProcess(t, info.HostPort())
-
-		// Verify both ports are now free
-		waitForPortsClosed(t, info.CorePort(), info.HostPort(), defaultTimeout)
-	}
-}

cli/e2e/sqlite_helper.go

@@ -1,161 +0,0 @@
-package e2e
-
-import (
-	"database/sql"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/cline/cli/pkg/common"
-	_ "github.com/mattn/go-sqlite3"
-	"google.golang.org/grpc/health/grpc_health_v1"
-)
-
-// readInstancesFromSQLite reads instances directly from the SQLite database for testing
-func readInstancesFromSQLite(t *testing.T, clineDir string) []common.CoreInstanceInfo {
-	t.Helper()
-
-	dbPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "locks.db")
-
-	// Check if database exists
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		return []common.CoreInstanceInfo{}
-	}
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		t.Logf("Warning: Failed to open SQLite database: %v", err)
-		return []common.CoreInstanceInfo{}
-	}
-	defer db.Close()
-
-	// Query instance locks
-	query := common.SelectInstanceLockHoldersAscSQL
-
-	rows, err := db.Query(query)
-	if err != nil {
-		t.Logf("Warning: Failed to query instance locks: %v", err)
-		return []common.CoreInstanceInfo{}
-	}
-	defer rows.Close()
-
-	var instances []common.CoreInstanceInfo
-	for rows.Next() {
-		var heldBy, lockTarget string
-		var lockedAt int64
-
-		err := rows.Scan(&heldBy, &lockTarget, &lockedAt)
-		if err != nil {
-			t.Logf("Warning: Failed to scan lock row: %v", err)
-			continue
-		}
-
-		// Create InstanceInfo
-		info := common.CoreInstanceInfo{
-			Address:            heldBy,
-			HostServiceAddress: lockTarget,
-			Status:             grpc_health_v1.HealthCheckResponse_UNKNOWN, // Will be updated by health check
-			LastSeen:           time.Unix(lockedAt/1000, 0),                // Convert from milliseconds
-		}
-
-		instances = append(instances, info)
-	}
-
-	return instances
-}
-
-// readDefaultInstanceFromSettings reads the default instance from the settings file
-func readDefaultInstanceFromSettings(t *testing.T, clineDir string) string {
-	t.Helper()
-
-	settingsPath := filepath.Join(clineDir, common.SETTINGS_SUBFOLDER, "settings", "cli-default-instance.json")
-
-	data, err := os.ReadFile(settingsPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return ""
-		}
-		t.Logf("Warning: Failed to read default instance file: %v", err)
-		return ""
-	}
-
-	var tmp struct {
-		DefaultInstance string `json:"default_instance"`
-	}
-	if err := json.Unmarshal(data, &tmp); err != nil {
-		t.Logf("Warning: Failed to parse default instance file: %v", err)
-		return ""
-	}
-
-	return tmp.DefaultInstance
-}
-
-// insertRemoteInstanceIntoSQLite inserts a remote instance entry directly into SQLite for testing
-func insertRemoteInstanceIntoSQLite(t *testing.T, dbPath, address string, corePort, hostPort int) error {
-	t.Helper()
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	// Initialize database schema for testing
-	createTableSQL := `
-		CREATE TABLE IF NOT EXISTS locks (
-			id INTEGER PRIMARY KEY,
-			held_by TEXT NOT NULL,
-			lock_type TEXT NOT NULL CHECK (lock_type IN ('file', 'instance', 'folder')),
-			lock_target TEXT NOT NULL,
-			locked_at INTEGER NOT NULL,
-			UNIQUE(lock_type, lock_target)
-		);
-	`
-	createIndexesSQL := `
-		CREATE INDEX IF NOT EXISTS idx_locks_held_by ON locks(held_by);
-		CREATE INDEX IF NOT EXISTS idx_locks_type ON locks(lock_type);
-		CREATE INDEX IF NOT EXISTS idx_locks_target ON locks(lock_target);
-	`
-
-	if _, err := db.Exec(createTableSQL); err != nil {
-		return err
-	}
-	if _, err := db.Exec(createIndexesSQL); err != nil {
-		return err
-	}
-
-	// Insert the remote instance
-	hostAddress := "remote.example.com:0"
-	if hostPort != 0 {
-		hostAddress = "remote.example.com:" + strconv.Itoa(hostPort)
-	}
-
-	insertSQL := `INSERT INTO locks (held_by, lock_type, lock_target, locked_at) VALUES (?, 'instance', ?, ?)`
-	_, err = db.Exec(insertSQL, address, hostAddress, time.Now().Unix()*1000)
-	return err
-}
-
-// verifyInstanceExistsInSQLite checks if an instance exists in the SQLite database
-func verifyInstanceExistsInSQLite(t *testing.T, dbPath, address string) bool {
-	t.Helper()
-
-	db, err := sql.Open("sqlite3", dbPath)
-	if err != nil {
-		t.Logf("Failed to open database: %v", err)
-		return false
-	}
-	defer db.Close()
-
-	query := `SELECT COUNT(*) FROM locks WHERE held_by = ? AND lock_type = 'instance'`
-	var count int
-	err = db.QueryRow(query, address).Scan(&count)
-	if err != nil {
-		t.Logf("Failed to query database: %v", err)
-		return false
-	}
-
-	return count > 0
-}

cli/e2e/start_list_test.go

@@ -1,178 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"fmt"
-	"syscall"
-	"testing"
-)
-
-// TestStartAndList verifies self-registration and default.json semantics in a fresh CLINE_DIR.
-func TestStartAndList(t *testing.T) {
-	clineDir := setTempClineDir(t)
-	t.Logf("Using temp CLINE_DIR: %s", clineDir)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	t.Logf("Starting new instance...")
-	// Start a new instance
-	startOutput := mustRunCLI(ctx, t, "instance", "new")
-	t.Logf("Instance start output: %s", startOutput)
-
-	t.Logf("Listing instances to check registration...")
-	// It should appear healthy in list JSON and be the default.
-	out := listInstancesJSON(ctx, t)
-	t.Logf("Found %d instances after start", len(out.CoreInstances))
-
-	if len(out.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out.CoreInstances))
-	}
-
-	addr := out.CoreInstances[0].Address
-	t.Logf("Instance address: %s, status: %s", addr, out.CoreInstances[0].Status)
-
-	t.Logf("Waiting for address %s to become healthy...", addr)
-	waitForAddressHealthy(t, addr, defaultTimeout)
-	t.Logf("Address %s is now healthy", addr)
-
-	t.Logf("Checking default instance configuration...")
-	// Default should be set to the new instance.
-	out = listInstancesJSON(ctx, t)
-	t.Logf("Default instance: %s", out.DefaultInstance)
-
-	if out.DefaultInstance == "" {
-		t.Fatalf("default_instance not set")
-	}
-	if out.DefaultInstance != out.CoreInstances[0].Address {
-		t.Fatalf("expected default_instance=%s, got %s", out.CoreInstances[0].Address, out.DefaultInstance)
-	}
-
-	t.Logf("TestStartAndList completed successfully")
-}
-
-// TestTaskNewDefault ensures tasks route to default instance.
-func TestTaskNewDefault(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start one instance and wait for healthy
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) != 1 {
-		t.Fatalf("expected 1 instance, got %d", len(out.CoreInstances))
-	}
-	addr := out.CoreInstances[0].Address
-	waitForAddressHealthy(t, addr, defaultTimeout)
-
-	// Create a new task at default (success is sufficient)
-	_ = mustRunCLI(ctx, t, "task", "new", "hello world")
-}
-
-// TestExplicitAddressAutoStart verifies that giving an explicit address auto-starts an instance and routes the task.
-func TestExplicitAddressAutoStart(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Find a free port and use explicit address. This should auto-start an instance.
-	port := findFreePort(t)
-	addr := "localhost:" + itoa(port)
-
-	// Run a task at explicit address (auto-start path)
-	_ = mustRunCLI(ctx, t, "task", "new", "--address", "localhost:"+itoa(port), "explicit address task")
-
-	// Verify the instance is present and healthy
-	waitForAddressHealthy(t, addr, defaultTimeout)
-}
-
-// TestCrashCleanup verifies that after SIGKILL of a local core, the cleanup removes the registry entry.
-// Also tests graceful shutdown (SIGTERM) vs crash cleanup and ensures no dangling host processes.
-func TestCrashCleanup(t *testing.T) {
-	_ = setTempClineDir(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), longTimeout)
-	defer cancel()
-
-	// Start two instances for testing both graceful and crash scenarios
-	_ = mustRunCLI(ctx, t, "instance", "new")
-	_ = mustRunCLI(ctx, t, "instance", "new")
-
-	out := listInstancesJSON(ctx, t)
-	if len(out.CoreInstances) < 2 {
-		t.Fatalf("expected at least 2 instances, got %d", len(out.CoreInstances))
-	}
-
-	// Test 1: Graceful shutdown (SIGTERM) - should clean up both processes
-	gracefulTarget := out.CoreInstances[0]
-	waitForAddressHealthy(t, gracefulTarget.Address, defaultTimeout)
-
-	// Get PID using runtime discovery
-	gracefulPID := getCorePID(t, gracefulTarget.Address)
-	if gracefulPID <= 0 {
-		t.Fatalf("could not find PID for graceful target at %s", gracefulTarget.Address)
-	}
-
-	t.Logf("Testing graceful shutdown (SIGTERM) for instance %s (PID %d)", gracefulTarget.Address, gracefulPID)
-	if err := syscall.Kill(gracefulPID, syscall.SIGTERM); err != nil {
-		t.Fatalf("kill SIGTERM pid %d: %v", gracefulPID, err)
-	}
-
-	// Wait for registry cleanup
-	waitForAddressRemoved(t, gracefulTarget.Address, longTimeout)
-
-	// Verify both core and host ports are freed (no dangling processes)
-	waitForPortsClosed(t, gracefulTarget.CorePort(), gracefulTarget.HostPort(), defaultTimeout)
-
-	// Verify the instance is removed from SQLite (no file to check anymore)
-	// The waitForAddressRemoved already confirms the instance is gone from the registry
-
-	// Test 2: Crash cleanup (SIGKILL) - creates dangling host process that we must clean up
-	crashTarget := out.CoreInstances[1]
-	waitForAddressHealthy(t, crashTarget.Address, defaultTimeout)
-
-	// Get PID using runtime discovery
-	crashPID := getCorePID(t, crashTarget.Address)
-	if crashPID <= 0 {
-		t.Fatalf("could not find PID for crash target at %s", crashTarget.Address)
-	}
-
-	t.Logf("Testing crash cleanup (SIGKILL) for instance %s (PID %d)", crashTarget.Address, crashPID)
-	if err := syscall.Kill(crashPID, syscall.SIGKILL); err != nil {
-		t.Fatalf("kill SIGKILL pid %d: %v", crashPID, err)
-	}
-
-	// Wait for registry cleanup
-	waitForAddressRemoved(t, crashTarget.Address, longTimeout)
-
-	// Verify the instance is removed from SQLite (no file to check anymore)
-	// The waitForAddressRemoved already confirms the instance is gone from the registry
-
-	// Clean up dangling host process (SIGKILL leaves these behind by design)
-	t.Logf("Cleaning up dangling host process %s", crashTarget.HostServiceAddress)
-	findAndKillHostProcess(t, crashTarget.HostPort())
-
-	// Verify both ports are now free
-	waitForPortsClosed(t, crashTarget.CorePort(), crashTarget.HostPort(), defaultTimeout)
-}
-
-// itoa is a small helper for readability
-func itoa(i int) string {
-	return strconvItoa(i)
-}
-
-// minimal inline int->string to avoid extra imports in helpers
-func strconvItoa(i int) string {
-	// simple fast path
-	return fmtInt(i)
-}
-
-func fmtInt(i int) string {
-	// allocate small buffer; ints here are short
-	return (func(n int) string {
-		return fmt.Sprintf("%d", n)
-	})(i)
-}

cli/go.mod

@@ -1,58 +0,0 @@
-module github.com/cline/cli
-
-go 1.23.0
-
-require (
-	github.com/atotto/clipboard v0.1.4
-	github.com/charmbracelet/glamour v0.10.0
-	github.com/charmbracelet/huh v0.7.1-0.20251005153135-a01a1e304532
-	github.com/cline/grpc-go v0.0.0
-	github.com/mattn/go-sqlite3 v1.14.24
-	github.com/spf13/cobra v1.8.0
-	golang.org/x/term v0.32.0
-	google.golang.org/grpc v1.75.0
-	google.golang.org/protobuf v1.36.6
-)
-
-replace github.com/cline/grpc-go => ../src/generated/grpc-go
-
-require (
-	github.com/alecthomas/chroma/v2 v2.14.0 // indirect
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
-	github.com/catppuccin/go v0.3.0 // indirect
-	github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 // indirect
-	github.com/charmbracelet/bubbletea v1.3.6 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
-	github.com/charmbracelet/x/ansi v0.9.3 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
-	github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
-	github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect
-	github.com/charmbracelet/x/term v0.2.1 // indirect
-	github.com/dlclark/regexp2 v1.11.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/gorilla/css v1.0.1 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
-	github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/reflow v0.3.0 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	github.com/yuin/goldmark v1.7.8 // indirect
-	github.com/yuin/goldmark-emoji v1.0.5 // indirect
-	golang.org/x/net v0.41.0 // indirect
-	golang.org/x/sync v0.15.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.26.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 // indirect
-)

cli/go.sum

@@ -1,150 +0,0 @@
-github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
-github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
-github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
-github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
-github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
-github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
-github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
-github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY=
-github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=
-github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
-github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
-github.com/catppuccin/go v0.3.0 h1:d+0/YicIq+hSTo5oPuRi5kOpqkVA5tAsU6dNhvRu+aY=
-github.com/catppuccin/go v0.3.0/go.mod h1:8IHJuMGaUUjQM82qBrGNBv7LFq6JI3NnQCF6MOlZjpc=
-github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 h1:JFgG/xnwFfbezlUnFMJy0nusZvytYysV4SCS2cYbvws=
-github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7/go.mod h1:ISC1gtLcVilLOf23wvTfoQuYbW2q0JevFxPfUzZ9Ybw=
-github.com/charmbracelet/bubbletea v1.3.6 h1:VkHIxPJQeDt0aFJIsVxw8BQdh/F/L2KKZGsK6et5taU=
-github.com/charmbracelet/bubbletea v1.3.6/go.mod h1:oQD9VCRQFF8KplacJLo28/jofOI2ToOfGYeFgBBxHOc=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
-github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
-github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
-github.com/charmbracelet/huh v0.7.1-0.20251005153135-a01a1e304532 h1:+xmbw70JXxmsOqvm1PEIAqFnqI/Hy2RYqrK7CtPmsNY=
-github.com/charmbracelet/huh v0.7.1-0.20251005153135-a01a1e304532/go.mod h1:5YVc+SlZ1IhQALxRPpkGwwEKftN/+OlJlnJYlDRFqN4=
-github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
-github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
-github.com/charmbracelet/x/ansi v0.9.3 h1:BXt5DHS/MKF+LjuK4huWrC6NCvHtexww7dMayh6GXd0=
-github.com/charmbracelet/x/ansi v0.9.3/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
-github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
-github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
-github.com/charmbracelet/x/conpty v0.1.0 h1:4zc8KaIcbiL4mghEON8D72agYtSeIgq8FSThSPQIb+U=
-github.com/charmbracelet/x/conpty v0.1.0/go.mod h1:rMFsDJoDwVmiYM10aD4bH2XiRgwI7NYJtQgl5yskjEQ=
-github.com/charmbracelet/x/errors v0.0.0-20240508181413-e8d8b6e2de86 h1:JSt3B+U9iqk37QUU2Rvb6DSBYRLtWqFqfxf8l5hOZUA=
-github.com/charmbracelet/x/errors v0.0.0-20240508181413-e8d8b6e2de86/go.mod h1:2P0UgXMEa6TsToMSuFqKFQR+fZTO9CNGUNokkPatT/0=
-github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
-github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
-github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf h1:rLG0Yb6MQSDKdB52aGX55JT1oi0P0Kuaj7wi1bLUpnI=
-github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf/go.mod h1:B3UgsnsBZS/eX42BlaNiJkD1pPOUa+oF1IYC6Yd2CEU=
-github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 h1:qko3AQ4gK1MTS/de7F5hPGx6/k1u0w4TeYmBFwzYVP4=
-github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0/go.mod h1:pBhA0ybfXv6hDjQUZ7hk1lVxBiUbupdw5R31yPUViVQ=
-github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
-github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
-github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8JawjaNZY=
-github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=
-github.com/charmbracelet/x/xpty v0.1.2 h1:Pqmu4TEJ8KeA9uSkISKMU3f+C1F6OGBn8ABuGlqCbtI=
-github.com/charmbracelet/x/xpty v0.1.2/go.mod h1:XK2Z0id5rtLWcpeNiMYBccNNBrP2IJnzHI0Lq13Xzq4=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
-github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
-github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
-github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
-github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
-github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
-github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
-github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
-github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
-github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
-github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
-github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
-github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic=
-github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
-github.com/yuin/goldmark-emoji v1.0.5 h1:EMVWyCGPlXJfUXBXpuMu+ii3TIaxbVBnEX9uaDC4cIk=
-github.com/yuin/goldmark-emoji v1.0.5/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
-go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
-gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
-gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 h1:pFyd6EwwL2TqFf8emdthzeX+gZE1ElRq3iM8pui4KBY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
-google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
-google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cli/pkg/cli/auth.go

@@ -1,17 +0,0 @@
-package cli
-
-import (
-	"github.com/cline/cli/pkg/cli/auth"
-	"github.com/spf13/cobra"
-)
-
-func NewAuthCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:   "auth",
-		Short: "Sign in to Cline",
-		Long:  `Complete the authentication flow in browser to sign in to Cline.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return auth.RunAuthFlow(cmd.Context(), args)
-		},
-	}
-}

cli/pkg/cli/auth/auth_cline_provider.go

@@ -1,282 +0,0 @@
-package auth
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-)
-
-var isSessionAuthenticated bool
-
-// Cline provider specific code
-
-func HandleClineAuth(ctx context.Context) error {
-	verboseLog("Authenticating with Cline...")
-
-	// Check if already authenticated
-	if IsAuthenticated(ctx) {
-		return signOutDialog(ctx)
-	}
-
-	// Perform sign in
-	if err := signIn(ctx); err != nil {
-		return err
-	}
-
-	fmt.Println()
-	
-	verboseLog("✓ You are signed in!")
-	
-
-	// Configure default Cline model after successful authentication
-	if err := configureDefaultClineModel(ctx); err != nil {
-		fmt.Printf("Warning: Could not configure default Cline model: %v\n", err)
-		fmt.Println("You can configure a model later with 'cline auth' and selecting 'Change Cline model'")
-	}
-
-	// Return to main auth menu after successful authentication
-	return HandleAuthMenuNoArgs(ctx)
-}
-
-func signOut(ctx context.Context) error {
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return err
-	}
-
-	if _, err = client.Account.AccountLogoutClicked(ctx, &cline.EmptyRequest{}); err != nil {
-		return err
-	}
-
-	isSessionAuthenticated = false
-	fmt.Println("You have been signed out of Cline.")
-	return nil
-}
-
-func signOutDialog(ctx context.Context) error {
-	var confirm bool
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewConfirm().
-				Title("You are already signed in to Cline.").
-				Description("Would you like to sign out?").
-				Value(&confirm),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return nil
-	}
-
-	if confirm {
-		if err := signOut(ctx); err != nil {
-			fmt.Printf("Failed to sign out: %v\n", err)
-			return err
-		}
-	}
-	return HandleAuthMenuNoArgs(ctx)
-}
-
-func signIn(ctx context.Context) error {
-	if IsAuthenticated(ctx) {
-		return nil
-	}
-
-	// Subscribe to auth updates before initiating login
-	verboseLog("Subscribing to auth status updates...")
-	listener, err := NewAuthStatusListener(ctx)
-	if err != nil {
-		verboseLog("Failed to subscribe to auth updates: %v", err)
-		return fmt.Errorf("failed to subscribe to auth updates: %w", err)
-	}
-	defer listener.Stop()
-
-	if err := listener.Start(); err != nil {
-		verboseLog("Failed to start auth listener: %v", err)
-		return fmt.Errorf("failed to start auth listener: %w", err)
-	}
-
-	// Initiate login (opens browser with callback URL from cline-core's AuthHandler)
-	verboseLog("Initiating login...")
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		verboseLog("Failed to obtain client: %v", err)
-		return fmt.Errorf("failed to obtain client: %w", err)
-	}
-
-	_, err = client.Account.AccountLoginClicked(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		verboseLog("Failed to initiate login: %v", err)
-		return fmt.Errorf("failed to initiate login: %w", err)
-	}
-
-	fmt.Println("\n  Opening browser for authentication...")
-	fmt.Println("  Waiting for you to complete authentication in your browser...")
-	fmt.Println("   (This may take a few moments. Timeout: 5 minutes)")
-
-	// Wait for auth status update confirming success
-	verboseLog("Waiting for authentication to complete...")
-	if err := listener.WaitForAuthentication(5 * time.Minute); err != nil {
-		verboseLog("Authentication failed or timed out: %v", err)
-		fmt.Println("\n  Authentication failed or timed out.")
-		fmt.Println("  Please try again with 'cline auth'")
-		return err
-	}
-
-	// Only NOW set the session flag after confirmed authentication
-	isSessionAuthenticated = true
-	verboseLog("Login successful")
-	return nil
-}
-
-func IsAuthenticated(ctx context.Context) bool {
-	if isSessionAuthenticated {
-		verboseLog("Session is already authenticated")
-		return true
-	}
-
-	verboseLog("Verifying authentication with server...")
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		verboseLog("Failed to get client for auth check: %v", err)
-		return false
-	}
-
-	_, err = client.Account.GetUserCredits(ctx, &cline.EmptyRequest{})
-	if err == nil {
-		// Update session variable for future fast-path checks
-		verboseLog("Server verification successful, updating session flag")
-		isSessionAuthenticated = true
-		return true
-	}
-
-	verboseLog("Server verification failed: %v", err)
-	return false
-}
-
-// HandleChangeClineModel allows Cline-authenticated users to change their Cline model selection. Hidden when not authenticated.
-func HandleChangeClineModel(ctx context.Context) error {
-	// Ensure user is authenticated
-	if !IsAuthenticated(ctx) {
-		return fmt.Errorf("you must be authenticated with Cline to change models. Run 'cline auth' to sign in")
-	}
-
-	// Get task manager
-	manager, err := createTaskManager(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to create task manager: %w", err)
-	}
-
-	// Launch Cline model selection
-	return SelectClineModel(ctx, manager)
-}
-
-// configureDefaultClineModel configures the default Cline model after authentication
-func configureDefaultClineModel(ctx context.Context) error {
-	verboseLog("Configuring default Cline model...")
-
-	// Create task manager
-	manager, err := task.NewManagerForDefault(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to create task manager: %w", err)
-	}
-
-	// Set default Cline model
-	return SetDefaultClineModel(ctx, manager)
-}
-
-// HandleSelectOrganization allows Cline-authenticated users to select which organization to use
-func HandleSelectOrganization(ctx context.Context) error {
-	// Ensure user is authenticated
-	if !IsAuthenticated(ctx) {
-		return fmt.Errorf("you must be authenticated with Cline to select an organization. Run 'cline auth' to sign in")
-	}
-
-	// Get client
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get client: %w", err)
-	}
-
-	// Fetch user organizations
-	orgsResponse, err := client.Account.GetUserOrganizations(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to fetch organizations: %w", err)
-	}
-
-	organizations := orgsResponse.GetOrganizations()
-	if len(organizations) == 0 {
-		fmt.Println("You don't have any organizations yet.")
-		fmt.Println("Visit https://app.cline.bot/dashboard to create an organization.")
-		return HandleAuthMenuNoArgs(ctx)
-	}
-
-	// Build options list: Personal + Organizations
-	var options []huh.Option[string]
-	options = append(options, huh.NewOption("Personal", "personal"))
-
-	for _, org := range organizations {
-		displayName := org.Name
-		// Show active indicator
-		if org.Active {
-			displayName = fmt.Sprintf("%s (active)", displayName)
-		}
-		options = append(options, huh.NewOption(displayName, org.OrganizationId))
-	}
-
-	options = append(options, huh.NewOption("(Cancel)", "cancel"))
-
-	// Show selection menu
-	var selected string
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[string]().
-				Title("Select which account to use").
-				Options(options...).
-				Value(&selected),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return fmt.Errorf("failed to select organization: %w", err)
-	}
-
-	if selected == "cancel" {
-		return HandleAuthMenuNoArgs(ctx)
-	}
-
-	// Set the organization
-	var orgId *string
-	if selected != "personal" {
-		orgId = &selected
-	}
-
-	req := &cline.UserOrganizationUpdateRequest{
-		OrganizationId: orgId,
-	}
-
-	if _, err := client.Account.SetUserOrganization(ctx, req); err != nil {
-		return fmt.Errorf("failed to set organization: %w", err)
-	}
-
-	if selected == "personal" {
-		fmt.Println("✓ Switched to personal account")
-	} else {
-		// Find the org name to display
-		var orgName string
-		for _, org := range organizations {
-			if org.OrganizationId == selected {
-				orgName = org.Name
-				break
-			}
-		}
-		fmt.Printf("✓ Switched to organization: %s\n", orgName)
-	}
-
-	return HandleAuthMenuNoArgs(ctx)
-}

cli/pkg/cli/auth/auth_menu.go

@@ -1,305 +0,0 @@
-package auth
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-)
-
-// contextKey is a distinct type for context keys to avoid collisions
-type contextKey string
-
-const authInstanceAddressKey contextKey = "authInstanceAddress"
-
-// AuthAction represents the type of authentication action
-type AuthAction string
-
-const (
-	AuthActionClineLogin         AuthAction = "cline_login"
-	AuthActionBYOSetup           AuthAction = "provider_setup"
-	AuthActionChangeClineModel   AuthAction = "change_cline_model"
-	AuthActionSelectOrganization AuthAction = "select_organization"
-	AuthActionSelectProvider     AuthAction = "select_provider"
-	AuthActionExit               AuthAction = "exit_wizard"
-)
-
-//  Cline Auth Menu
-//  Example Layout
-//
-//	┃ Cline Account: <authenticated/not authenticated>
-//	┃ Active Provider: <provider name or none configured>
-//	┃ Active Model: <model name or none configured>
-//	┃
-//	┃ What would you like to do?
-//	┃   Change Cline model (only if authenticated)				- hidden if not authenticated
-//	┃   Authenticate with Cline account / Sign out of Cline		- changes based on auth status
-//	┃   Select active provider (Cline or BYO)					- always shown. Used to switch between Cline and BYO providers
-//	┃   Configure API provider									- always shown. Launches provider setup wizard
-//	┃   Exit authorization wizard								- always shown. Exits the auth menu
-
-// RunAuthFlow is the entry point for the entire auth flow with instance management
-// It spawns a fresh instance for auth operations and cleans it up when done
-func RunAuthFlow(ctx context.Context, args []string) error {
-	// Spawn a fresh instance for auth operations
-	instanceInfo, err := global.Clients.StartNewInstance(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to start auth instance: %w", err)
-	}
-
-	// Cleanup when done (success, error, or panic)
-	defer func() {
-		verboseLog("Shutting down auth instance at %s", instanceInfo.Address)
-		if err := global.KillInstanceByAddress(context.Background(), global.Clients.GetRegistry(), instanceInfo.Address); err != nil {
-			verboseLog("Warning: Failed to kill auth instance: %v", err)
-		}
-	}()
-
-	// Store instance address in context for all auth handlers to use
-	authCtx := context.WithValue(ctx, authInstanceAddressKey, instanceInfo.Address)
-
-	// Route to existing auth flow
-	return HandleAuthCommand(authCtx, args)
-}
-
-// Main entry point for handling the `cline auth` command
-// HandleAuthCommand routes the auth command based on the number of arguments
-func HandleAuthCommand(ctx context.Context, args []string) error {
-	switch len(args) {
-	case 0:
-		// No args: Show menu (ShowAuthMenuNoArgs)
-		return HandleAuthMenuNoArgs(ctx)
-	case 1:
-		// One arg: Provider ID only, prompt for API key
-		return QuickAPISetup(args[0], "")
-	case 2:
-		// Two args: Provider ID and API key
-		return QuickAPISetup(args[0], args[1])
-	default:
-		return fmt.Errorf("quick BYO API setup is currently stubbed - not yet implemented")
-	}
-}
-
-// getAuthInstanceAddress retrieves the auth instance address from context
-// Returns empty string if not found (falls back to default behavior)
-func getAuthInstanceAddress(ctx context.Context) string {
-	if addr, ok := ctx.Value(authInstanceAddressKey).(string); ok {
-		return addr
-	}
-	return ""
-}
-
-// HandleAuthMenuNoArgs prepares the auth menu when no arguments are provided
-func HandleAuthMenuNoArgs(ctx context.Context) error {
-	// Check if Cline is authenticated
-	isClineAuth := IsAuthenticated(ctx)
-
-	// Get current provider config for display
-	var currentProvider string
-	var currentModel string
-	if manager, err := createTaskManager(ctx); err == nil {
-		if providerList, err := GetProviderConfigurations(ctx, manager); err == nil {
-			if providerList.ActProvider != nil {
-				currentProvider = getProviderDisplayName(providerList.ActProvider.Provider)
-				currentModel = providerList.ActProvider.ModelID
-			}
-		}
-	}
-
-	// Fetch organizations if authenticated
-	var hasOrganizations bool
-	if isClineAuth {
-		if client, err := global.GetDefaultClient(ctx); err == nil {
-			if orgsResponse, err := client.Account.GetUserOrganizations(ctx, &cline.EmptyRequest{}); err == nil {
-				hasOrganizations = len(orgsResponse.GetOrganizations()) > 0
-			}
-		}
-	}
-
-	action, err := ShowAuthMenuWithStatus(isClineAuth, hasOrganizations, currentProvider, currentModel)
-	if err != nil {
-		return err
-	}
-
-	switch action {
-	case AuthActionClineLogin:
-		return HandleClineAuth(ctx)
-	case AuthActionBYOSetup:
-		return HandleAPIProviderSetup(ctx)
-	case AuthActionChangeClineModel:
-		return HandleChangeClineModel(ctx)
-	case AuthActionSelectOrganization:
-		return HandleSelectOrganization(ctx)
-	case AuthActionSelectProvider:
-		return HandleSelectProvider(ctx)
-	case AuthActionExit:
-		return nil
-	default:
-		return fmt.Errorf("invalid action")
-	}
-}
-
-// ShowAuthMenuWithStatus displays the main auth menu with Cline + provider status
-func ShowAuthMenuWithStatus(isClineAuthenticated bool, hasOrganizations bool, currentProvider, currentModel string) (AuthAction, error) {
-	var action AuthAction
-	var options []huh.Option[AuthAction]
-
-	// Build menu options based on authentication status
-	if isClineAuthenticated {
-		options = []huh.Option[AuthAction]{
-			huh.NewOption("Change Cline model", AuthActionChangeClineModel),
-		}
-
-		// Add organization selection if user has organizations
-		if hasOrganizations {
-			options = append(options, huh.NewOption("Select organization", AuthActionSelectOrganization))
-		}
-
-		options = append(options,
-			huh.NewOption("Sign out of Cline", AuthActionClineLogin),
-			huh.NewOption("Select active provider (Cline or BYO)", AuthActionSelectProvider),
-			huh.NewOption("Configure API provider", AuthActionBYOSetup),
-			huh.NewOption("Exit authorization wizard", AuthActionExit),
-		)
-	} else {
-		options = []huh.Option[AuthAction]{
-			huh.NewOption("Authenticate with Cline account", AuthActionClineLogin),
-			huh.NewOption("Select active provider (Cline or BYO)", AuthActionSelectProvider),
-			huh.NewOption("Configure API provider", AuthActionBYOSetup),
-			huh.NewOption("Exit authorization wizard", AuthActionExit),
-		}
-	}
-
-	// Determine menu title based on status
-	var title string
-
-	// Always show Cline authentication status
-	if isClineAuthenticated {
-		title = "Cline Account: \033[32m✓\033[0m Authenticated\n"
-	} else {
-		title = "Cline Account: \033[31m✗\033[0m Not authenticated\n"
-	}
-
-	// Show active provider and model if configured (regardless of Cline auth status)
-	// ANSI color codes: Normal intensity = \033[22m, White = \033[37m, Reset = \033[0m
-	if currentProvider != "" && currentModel != "" {
-		title += fmt.Sprintf("Active Provider: \033[22m\033[37m%s\033[0m\nActive Model: \033[22m\033[37m%s\033[0m\n", currentProvider, currentModel)
-	}
-
-	// Always end with a huh?
-	title += "\nWhat would you like to do?"
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[AuthAction]().
-				Title(title).
-				Options(options...).
-				Value(&action),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return "", fmt.Errorf("failed to get menu choice: %w", err)
-	}
-
-	return action, nil
-}
-
-// HandleAPIProviderSetup launches the API provider configuration wizard
-func HandleAPIProviderSetup(ctx context.Context) error {
-	wizard, err := NewProviderWizard(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to create provider wizard: %w", err)
-	}
-
-	return wizard.Run()
-}
-
-// HandleSelectProvider allows users to switch between Cline provider and BYO providers
-func HandleSelectProvider(ctx context.Context) error {
-	// Get task manager
-	manager, err := createTaskManager(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to create task manager: %w", err)
-	}
-
-	// Detect all providers with valid configurations (is an API key present)
-	availableProviders, err := DetectAllConfiguredProviders(ctx, manager)
-	if err != nil {
-		return fmt.Errorf("failed to detect configured providers: %w", err)
-	}
-
-	// Build list of available providers
-	var providerOptions []huh.Option[string]
-	var providerMapping = make(map[string]cline.ApiProvider)
-
-	// Add each configured provider to the selection menu
-	for _, provider := range availableProviders {
-		providerName := getProviderDisplayName(provider)
-		providerKey := fmt.Sprintf("provider_%d", provider)
-		providerOptions = append(providerOptions, huh.NewOption(providerName, providerKey))
-		providerMapping[providerKey] = provider
-	}
-
-	if len(providerOptions) == 0 {
-		fmt.Println("No providers available. Please configure a provider first.")
-		return HandleAuthMenuNoArgs(ctx)
-	}
-
-	if len(providerOptions) == 1 {
-		fmt.Println("Only one provider is configured. Configure another provider to switch between them.")
-		return HandleAuthMenuNoArgs(ctx)
-	}
-
-	providerOptions = append(providerOptions, huh.NewOption("(Cancel)", "cancel"))
-
-	// Show selection menu
-	var selected string
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[string]().
-				Title("Select which provider to use").
-				Options(providerOptions...).
-				Value(&selected),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return fmt.Errorf("failed to select provider: %w", err)
-	}
-
-	if selected == "cancel" {
-		return HandleAuthMenuNoArgs(ctx)
-	}
-
-	// Get the selected provider
-	selectedProvider := providerMapping[selected]
-
-	// Apply the selected provider
-	if selectedProvider == cline.ApiProvider_CLINE {
-		// Configure Cline as the active provider
-		return SelectClineModel(ctx, manager)
-	} else {
-		// Switch to the selected BYO provider
-		return SwitchToBYOProvider(ctx, manager, selectedProvider)
-	}
-}
-
-// createTaskManager is a helper to create a task manager (avoids import cycles)
-// Uses the auth instance address from context if available, otherwise falls back to default
-func createTaskManager(ctx context.Context) (*task.Manager, error) {
-	authAddr := getAuthInstanceAddress(ctx)
-	if authAddr != "" {
-		return task.NewManagerForAddress(ctx, authAddr)
-	}
-	return task.NewManagerForDefault(ctx)
-}
-
-func verboseLog(format string, args ...interface{}) {
-	if global.Config != nil && global.Config.Verbose {
-		fmt.Printf("[VERBOSE] "+format+"\n", args...)
-	}
-}

cli/pkg/cli/auth/auth_subscription.go

@@ -1,130 +0,0 @@
-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
-}

cli/pkg/cli/auth/byo_quick_setup.go

@@ -1,13 +0,0 @@
-package auth
-
-import "fmt"
-
-// QuickAPISetup performs quick provider setup with provider ID and optional API key
-func QuickAPISetup(providerID, apiKey string) error {
-	fmt.Println("Quick BYO API setup is currently stubbed - not yet implemented.")
-	fmt.Printf("Requested provider: %s\n", providerID)
-	if apiKey != "" {
-		fmt.Println("Provided API key:", "<jk redacted>")
-	}
-	return nil
-}

cli/pkg/cli/auth/models_byo.go

@@ -1 +0,0 @@
-package auth

cli/pkg/cli/auth/models_cline.go

@@ -1,141 +0,0 @@
-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
-}

cli/pkg/cli/auth/models_list_fetch.go

@@ -1,136 +0,0 @@
-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.RefreshOpenRouterModels(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch OpenRouter models: %w", err)
-	}
-	return resp.Models, nil
-}
-
-// 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
-}
-
-// 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
-}
-
-// 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
-}

cli/pkg/cli/auth/models_list_static.go

@@ -1,69 +0,0 @@
-package auth
-
-import (
-	"fmt"
-	"sort"
-
-	"github.com/cline/cli/pkg/generated"
-	"github.com/cline/grpc-go/cline"
-)
-
-// SupportsStaticModelList returns true if the provider has a predefined static model list
-func SupportsStaticModelList(provider cline.ApiProvider) bool {
-	providerID := GetProviderIDForEnum(provider)
-	if providerID == "" {
-		return false
-	}
-
-	// Check if this provider has static models defined
-	def, err := generated.GetProviderDefinition(providerID)
-	if err != nil {
-		return false
-	}
-
-	// Return true if provider has models and isn't dynamic-only
-	// (Dynamic providers like OpenRouter/OpenAI/Ollama fetch from API)
-	return len(def.Models) > 0 && !def.HasDynamicModels
-}
-
-// FetchStaticModels retrieves the static model list for a provider from generated definitions
-// Returns a sorted list of model IDs and a map of model IDs to their info
-func FetchStaticModels(provider cline.ApiProvider) ([]string, map[string]generated.ModelInfo, error) {
-	providerID := GetProviderIDForEnum(provider)
-	if providerID == "" {
-		return nil, nil, fmt.Errorf("unknown provider enum: %v", provider)
-	}
-
-	def, err := generated.GetProviderDefinition(providerID)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to get provider definition: %w", err)
-	}
-
-	if len(def.Models) == 0 {
-		return nil, nil, fmt.Errorf("no models defined for provider %s", providerID)
-	}
-
-	// Extract model IDs and sort them
-	modelIDs := make([]string, 0, len(def.Models))
-	for modelID := range def.Models {
-		modelIDs = append(modelIDs, modelID)
-	}
-	sort.Strings(modelIDs)
-
-	return modelIDs, def.Models, nil
-}
-
-// GetDefaultModelForProvider returns the default model ID for a provider if one is defined
-func GetDefaultModelForProvider(provider cline.ApiProvider) string {
-	providerID := GetProviderIDForEnum(provider)
-	if providerID == "" {
-		return ""
-	}
-
-	def, err := generated.GetProviderDefinition(providerID)
-	if err != nil {
-		return ""
-	}
-
-	return def.DefaultModelID
-}

cli/pkg/cli/auth/providers_byo.go

@@ -1,177 +0,0 @@
-package auth
-
-import (
-	"fmt"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/grpc-go/cline"
-)
-
-// BYOProviderOption represents a selectable BYO (bring-your-own) provider option
-type BYOProviderOption struct {
-	Name     string
-	Provider cline.ApiProvider
-}
-
-// GetBYOProviderList returns the list of supported BYO providers for CLI configuration.
-// This list excludes Cline provider which is handled separately.
-func GetBYOProviderList() []BYOProviderOption {
-	return []BYOProviderOption{
-		{Name: "Anthropic", Provider: cline.ApiProvider_ANTHROPIC},
-		{Name: "OpenAI", Provider: cline.ApiProvider_OPENAI},
-		{Name: "OpenAI Native", Provider: cline.ApiProvider_OPENAI_NATIVE},
-		{Name: "OpenRouter", Provider: cline.ApiProvider_OPENROUTER},
-		{Name: "X AI (Grok)", Provider: cline.ApiProvider_XAI},
-		{Name: "AWS Bedrock", Provider: cline.ApiProvider_BEDROCK},
-		{Name: "Google Gemini", Provider: cline.ApiProvider_GEMINI},
-		{Name: "Ollama", Provider: cline.ApiProvider_OLLAMA},
-		{Name: "Cerebras", Provider: cline.ApiProvider_CEREBRAS},
-	}
-}
-
-// SelectBYOProvider displays a menu for selecting a BYO provider.
-func SelectBYOProvider() (cline.ApiProvider, error) {
-	providers := GetBYOProviderList()
-	var selectedIndex int
-
-	options := make([]huh.Option[int], len(providers)+1)
-	for i, provider := range providers {
-		options[i] = huh.NewOption(provider.Name, i)
-	}
-	options[len(providers)] = huh.NewOption("(Cancel)", -1)
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[int]().
-				Title("Select an API provider").
-				Options(options...).
-				Value(&selectedIndex),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return 0, fmt.Errorf("failed to select provider: %w", err)
-	}
-
-	if selectedIndex == -1 {
-		return 0, fmt.Errorf("provider selection cancelled")
-	}
-
-	return providers[selectedIndex].Provider, nil
-}
-
-// SupportsBYOModelFetching returns true if the provider supports fetching models dynamically
-// from a remote API, or if it has a static list of predefined models.
-// This is used to determine whether to show a model list before prompting for manual entry.
-func SupportsBYOModelFetching(provider cline.ApiProvider) bool {
-	switch provider {
-	case cline.ApiProvider_OPENROUTER:
-		return true
-	case cline.ApiProvider_OPENAI:
-		return true
-	case cline.ApiProvider_OLLAMA:
-		return true
-	}
-
-	return SupportsStaticModelList(provider)
-}
-
-// GetBYOProviderPlaceholder returns a placeholder model ID for manual entry based on provider.
-func GetBYOProviderPlaceholder(provider cline.ApiProvider) string {
-	switch provider {
-	case cline.ApiProvider_ANTHROPIC:
-		return "e.g., claude-sonnet-4-5-20250929"
-	case cline.ApiProvider_OPENAI:
-		return "e.g., gpt-5-2025-08-07"
-	case cline.ApiProvider_OPENAI_NATIVE:
-		return "e.g., openai/gpt-oss-120b"
-	case cline.ApiProvider_OPENROUTER:
-		return "e.g., google/gemini-2.0-flash-exp:free"
-	case cline.ApiProvider_XAI:
-		return "e.g., grok-code-fast-1"
-	case cline.ApiProvider_BEDROCK:
-		return "e.g., anthropic.claude-sonnet-4-5-20250929-v1:0"
-	case cline.ApiProvider_GEMINI:
-		return "e.g., gemini-2.5-pro"
-	case cline.ApiProvider_OLLAMA:
-		return "e.g., qwen3-coder:30b"
-	case cline.ApiProvider_CEREBRAS:
-		return "e.g., gpt-oss-120b"
-	default:
-		return "Enter model ID"
-	}
-}
-
-// GetBYOAPIKeyFieldConfig returns field configuration for API key input based on provider.
-type APIKeyFieldConfig struct {
-	Title      string
-	EchoMode   huh.EchoMode
-	IsRequired bool
-}
-
-// GetBYOAPIKeyFieldConfig returns the configuration for the API key field based on provider.
-func GetBYOAPIKeyFieldConfig(provider cline.ApiProvider) APIKeyFieldConfig {
-	if provider == cline.ApiProvider_OLLAMA {
-		return APIKeyFieldConfig{
-			Title:      "Base URL (optional, press Enter for default)",
-			EchoMode:   huh.EchoModeNormal,
-			IsRequired: false,
-		}
-	}
-
-	return APIKeyFieldConfig{
-		Title:      "API Key",
-		EchoMode:   huh.EchoModePassword,
-		IsRequired: true,
-	}
-}
-
-// PromptForAPIKey prompts the user to enter an API key (or base URL for Ollama).
-// For OpenAI Native provider, also prompts for an optional base URL.
-func PromptForAPIKey(provider cline.ApiProvider) (string, error) {
-	var apiKey string
-	config := GetBYOAPIKeyFieldConfig(provider)
-
-	apiKeyField := huh.NewInput().
-		Title(config.Title).
-		EchoMode(config.EchoMode).
-		Value(&apiKey)
-
-	if config.IsRequired {
-		apiKeyField = apiKeyField.Validate(func(s string) error {
-			if s == "" {
-				return fmt.Errorf("API key cannot be empty")
-			}
-			return nil
-		})
-	}
-
-	form := huh.NewForm(huh.NewGroup(apiKeyField))
-
-	if err := form.Run(); err != nil {
-		return "", fmt.Errorf("failed to get API key: %w", err)
-	}
-
-	// For OpenAI Native provider, also prompt for base URL
-	if provider == cline.ApiProvider_OPENAI_NATIVE {
-		var baseURL string
-		baseURLForm := huh.NewForm(
-			huh.NewGroup(
-				huh.NewInput().
-					Title("Base URL (optional, for OpenAI-compatible providers)").
-					Placeholder("e.g., https://api.example.com/v1").
-					Value(&baseURL).
-					Description("Press Enter to skip if using standard OpenAI API"),
-			),
-		)
-
-		if err := baseURLForm.Run(); err != nil {
-			return "", fmt.Errorf("failed to get base URL: %w", err)
-		}
-
-		// TODO - connect baseURL
-		_ = baseURL
-	}
-
-	return apiKey, nil
-}

cli/pkg/cli/auth/providers_list.go

@@ -1,477 +0,0 @@
-package auth
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-)
-
-// ProviderDisplay represents a configured provider for display purposes
-type ProviderDisplay struct {
-	Mode      string            // "Plan" or "Act"
-	Provider  cline.ApiProvider // Provider enum
-	ModelID   string            // Model identifier
-	HasAPIKey bool              // Whether an API key is configured (never show actual key)
-	BaseURL   string            // Base URL for providers like Ollama (can be shown publicly)
-}
-
-// ProviderListResult holds the parsed provider configuration from state
-type ProviderListResult struct {
-	PlanProvider *ProviderDisplay
-	ActProvider  *ProviderDisplay
-	apiConfig    map[string]interface{} // Store the raw apiConfig for scanning all providers
-}
-
-// GetProviderConfigurations retrieves and parses provider configurations from Cline Core state
-func GetProviderConfigurations(ctx context.Context, manager *task.Manager) (*ProviderListResult, error) {
-	if global.Config.Verbose {
-		fmt.Println("[DEBUG] Retrieving provider configurations from Cline Core")
-	}
-
-	// Get latest state from Cline Core
-	state, err := manager.GetClient().State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to get state: %w", err)
-	}
-
-	stateJSON := state.StateJson
-
-	if global.Config.Verbose {
-		fmt.Printf("[DEBUG] Retrieved state, parsing JSON (length: %d)\n", len(stateJSON))
-	}
-
-	// Parse state_json as map[string]interface{}
-	var stateData map[string]interface{}
-	if err := json.Unmarshal([]byte(stateJSON), &stateData); err != nil {
-		return nil, fmt.Errorf("failed to parse state JSON: %w", err)
-	}
-
-	if global.Config.Verbose {
-		fmt.Printf("[DEBUG] Parsed state data with %d keys\n", len(stateData))
-	}
-
-	// Extract apiConfiguration object from state
-	apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
-	if !ok {
-		if global.Config.Verbose {
-			fmt.Println("[DEBUG] No apiConfiguration found in state")
-		}
-		return &ProviderListResult{
-			apiConfig: make(map[string]interface{}),
-		}, nil
-	}
-
-	if global.Config.Verbose {
-		fmt.Printf("[DEBUG] Found apiConfiguration with %d keys\n", len(apiConfig))
-	}
-
-	// Extract plan mode configuration
-	planProvider := extractProviderFromState(apiConfig, "plan")
-	if global.Config.Verbose && planProvider != nil {
-		fmt.Printf("[DEBUG] Plan mode: provider=%v, model=%s\n", planProvider.Provider, planProvider.ModelID)
-	}
-
-	// Extract act mode configuration
-	actProvider := extractProviderFromState(apiConfig, "act")
-	if global.Config.Verbose && actProvider != nil {
-		fmt.Printf("[DEBUG] Act mode: provider=%v, model=%s\n", actProvider.Provider, actProvider.ModelID)
-	}
-
-	return &ProviderListResult{
-		PlanProvider: planProvider,
-		ActProvider:  actProvider,
-		apiConfig:    apiConfig,
-	}, nil
-}
-
-// GetAllReadyProviders returns all providers that have both a model and API key configured
-func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
-	if r.apiConfig == nil {
-		return []*ProviderDisplay{}
-	}
-
-	var readyProviders []*ProviderDisplay
-	seenProviders := make(map[cline.ApiProvider]bool)
-
-	// Check all possible providers
-	allProviders := []cline.ApiProvider{
-		cline.ApiProvider_CLINE,
-		cline.ApiProvider_ANTHROPIC,
-		cline.ApiProvider_OPENAI,
-		cline.ApiProvider_OPENAI_NATIVE,
-		cline.ApiProvider_OPENROUTER,
-		cline.ApiProvider_XAI,
-		cline.ApiProvider_BEDROCK,
-		cline.ApiProvider_GEMINI,
-		cline.ApiProvider_OLLAMA,
-		cline.ApiProvider_CEREBRAS,
-	}
-
-	// Check each provider to see if it's ready to use
-	// We use "plan" mode to check, since both plan and act should have the same providers configured
-	for _, provider := range allProviders {
-		// Skip if we've already seen this provider
-		if seenProviders[provider] {
-			continue
-		}
-
-		// Check if this provider has an API key
-		hasAPIKey := checkAPIKeyExists(r.apiConfig, provider)
-		if !hasAPIKey {
-			continue
-		}
-
-		// Check if this provider has a model configured
-		modelID := getProviderSpecificModelID(r.apiConfig, "plan", provider)
-		if modelID == "" {
-			continue
-		}
-
-		// Get base URL for Ollama
-		baseURL := ""
-		if provider == cline.ApiProvider_OLLAMA {
-			if url, ok := r.apiConfig["ollamaBaseUrl"].(string); ok {
-				baseURL = url
-			}
-		}
-
-		// This provider is ready to use
-		readyProviders = append(readyProviders, &ProviderDisplay{
-			Mode:      "Ready",
-			Provider:  provider,
-			ModelID:   modelID,
-			HasAPIKey: hasAPIKey,
-			BaseURL:   baseURL,
-		})
-		seenProviders[provider] = true
-	}
-
-	return readyProviders
-}
-
-// extractProviderFromState extracts provider configuration for specific plan/act mode
-func extractProviderFromState(stateData map[string]interface{}, mode string) *ProviderDisplay {
-	// Build key names based on mode
-	providerKey := mode + "ModeApiProvider"
-
-	// Extract provider string from state
-	providerStr, ok := stateData[providerKey].(string)
-	if !ok || providerStr == "" {
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] No provider configured for %s mode\n", mode)
-		}
-		return nil
-	}
-
-	// Map provider string to enum
-	provider, ok := mapProviderStringToEnum(providerStr)
-	if !ok {
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] Unknown provider type: %s\n", providerStr)
-		}
-		return nil
-	}
-
-	// Get provider-specific model ID
-	modelID := getProviderSpecificModelID(stateData, mode, provider)
-
-	// Check if API key exists
-	hasAPIKey := checkAPIKeyExists(stateData, provider)
-
-	// Get base URL for Ollama (can be shown publicly)
-	baseURL := ""
-	if provider == cline.ApiProvider_OLLAMA {
-		if url, ok := stateData["ollamaBaseUrl"].(string); ok {
-			baseURL = url
-		}
-	}
-
-	return &ProviderDisplay{
-		Mode:      capitalizeMode(mode),
-		Provider:  provider,
-		ModelID:   modelID,
-		HasAPIKey: hasAPIKey,
-		BaseURL:   baseURL,
-	}
-}
-
-// mapProviderStringToEnum converts provider string from state to ApiProvider enum
-// Returns (provider, ok) where ok is false if the provider is unknown
-func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
-	// Map string values to enum values
-	switch providerStr {
-	case "anthropic":
-		return cline.ApiProvider_ANTHROPIC, true
-	case "openai":
-		return cline.ApiProvider_OPENAI, true
-	case "openai-native":
-		return cline.ApiProvider_OPENAI_NATIVE, true
-	case "openrouter":
-		return cline.ApiProvider_OPENROUTER, true
-	case "xai":
-		return cline.ApiProvider_XAI, true
-	case "bedrock":
-		return cline.ApiProvider_BEDROCK, true
-	case "gemini":
-		return cline.ApiProvider_GEMINI, true
-	case "ollama":
-		return cline.ApiProvider_OLLAMA, true
-	case "cerebras":
-		return cline.ApiProvider_CEREBRAS, true
-	case "cline":
-		return cline.ApiProvider_CLINE, true
-	default:
-		return cline.ApiProvider_ANTHROPIC, false // Return 0 value with false
-	}
-}
-
-// GetProviderIDForEnum converts a provider enum to the provider ID string
-// This is the inverse of mapProviderStringToEnum and is used for provider definitions
-func GetProviderIDForEnum(provider cline.ApiProvider) string {
-	switch provider {
-	case cline.ApiProvider_ANTHROPIC:
-		return "anthropic"
-	case cline.ApiProvider_OPENAI:
-		return "openai"
-	case cline.ApiProvider_OPENAI_NATIVE:
-		return "openai-native"
-	case cline.ApiProvider_OPENROUTER:
-		return "openrouter"
-	case cline.ApiProvider_XAI:
-		return "xai"
-	case cline.ApiProvider_BEDROCK:
-		return "bedrock"
-	case cline.ApiProvider_GEMINI:
-		return "gemini"
-	case cline.ApiProvider_OLLAMA:
-		return "ollama"
-	case cline.ApiProvider_CEREBRAS:
-		return "cerebras"
-	case cline.ApiProvider_CLINE:
-		return "cline"
-	default:
-		return ""
-	}
-}
-
-// getProviderSpecificModelID gets the provider-specific model ID field from state
-func getProviderSpecificModelID(stateData map[string]interface{}, mode string, provider cline.ApiProvider) string {
-	modelKey, err := GetModelIDFieldName(provider, mode)
-	if err != nil {
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] Error getting model ID field name: %v\n", err)
-		}
-		return ""
-	}
-
-	if global.Config.Verbose {
-		fmt.Printf("[DEBUG] Looking for model ID in key: %s\n", modelKey)
-	}
-
-	// Extract model ID from state
-	modelID, _ := stateData[modelKey].(string)
-	return modelID
-}
-
-// checkAPIKeyExists checks if API key field exists in state (never retrieve actual key)
-func checkAPIKeyExists(stateData map[string]interface{}, provider cline.ApiProvider) bool {
-	// Get field mapping from centralized function
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return false
-	}
-
-	keyField := fields.APIKeyField
-
-	// Check if the key exists and is not empty
-	if value, ok := stateData[keyField]; ok {
-		if str, ok := value.(string); ok && str != "" {
-			return true
-		}
-	}
-
-	return false
-}
-
-// capitalizeMode capitalizes the mode string for display
-func capitalizeMode(mode string) string {
-	if len(mode) == 0 {
-		return mode
-	}
-	return strings.ToUpper(mode[:1]) + mode[1:]
-}
-
-// getProviderDisplayName returns a user-friendly name for the provider
-func getProviderDisplayName(provider cline.ApiProvider) string {
-	switch provider {
-	case cline.ApiProvider_ANTHROPIC:
-		return "Anthropic"
-	case cline.ApiProvider_OPENAI:
-		return "OpenAI"
-	case cline.ApiProvider_OPENAI_NATIVE:
-		return "OpenAI Native"
-	case cline.ApiProvider_OPENROUTER:
-		return "OpenRouter"
-	case cline.ApiProvider_XAI:
-		return "X AI (Grok)"
-	case cline.ApiProvider_BEDROCK:
-		return "AWS Bedrock"
-	case cline.ApiProvider_GEMINI:
-		return "Google Gemini"
-	case cline.ApiProvider_OLLAMA:
-		return "Ollama"
-	case cline.ApiProvider_CEREBRAS:
-		return "Cerebras"
-	case cline.ApiProvider_CLINE:
-		return "Cline (Official)"
-	default:
-		return "Unknown"
-	}
-}
-
-// FormatProviderList formats the complete provider list for console display
-// This now shows ALL providers that have both a model and API key configured
-func FormatProviderList(result *ProviderListResult) string {
-	var output strings.Builder
-
-	output.WriteString("\n=== Configured API Providers ===\n\n")
-
-	// Get the currently active provider
-	var activeProvider cline.ApiProvider
-	var activeProviderSet bool
-	if result.ActProvider != nil {
-		activeProvider = result.ActProvider.Provider
-		activeProviderSet = true
-	}
-
-	// Get all ready-to-use providers (those with both API key and model configured)
-	readyProviders := result.GetAllReadyProviders()
-
-	if len(readyProviders) == 0 {
-		output.WriteString("  No providers ready to use.\n")
-		output.WriteString("  A provider is ready when it has both a model and API key configured.\n")
-		output.WriteString("  Use 'Configure a new provider' to configure one.\n\n")
-	} else {
-		//output.WriteString(fmt.Sprintf("  %d provider(s) ready to use:\n\n", len(readyProviders)))
-
-		for _, display := range readyProviders {
-			// Check if this is the active provider
-			isActive := activeProviderSet && display.Provider == activeProvider
-
-			if isActive {
-				output.WriteString(fmt.Sprintf("  ✓ %s (ACTIVE)\n", getProviderDisplayName(display.Provider)))
-			} else {
-				output.WriteString(fmt.Sprintf("  • %s\n", getProviderDisplayName(display.Provider)))
-			}
-
-			output.WriteString(fmt.Sprintf("    Model:    %s\n", display.ModelID))
-
-			// Show status based on provider type
-			if display.Provider == cline.ApiProvider_OLLAMA {
-				if display.BaseURL != "" {
-					output.WriteString(fmt.Sprintf("    Base URL: %s\n", display.BaseURL))
-				} else {
-					output.WriteString("    Base URL: (default)\n")
-				}
-			} else if display.Provider == cline.ApiProvider_CLINE {
-				output.WriteString("    Status:   Authenticated\n")
-			} else {
-				output.WriteString("    API Key:  Configured\n")
-			}
-
-			output.WriteString("\n")
-		}
-	}
-
-	output.WriteString("================================\n")
-
-	return output.String()
-}
-
-// DetectAllConfiguredProviders scans the state to find all providers that have API keys configured.
-// This allows switching between multiple providers even when only one is currently active.
-func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([]cline.ApiProvider, error) {
-	verboseLog("[DEBUG] Detecting all configured providers...")
-
-	// Get latest state from Cline Core
-	state, err := manager.GetClient().State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to get state: %w", err)
-	}
-
-	stateJSON := state.StateJson
-
-	// Parse state_json as map[string]interface{}
-	var stateData map[string]interface{}
-	if err := json.Unmarshal([]byte(stateJSON), &stateData); err != nil {
-		return nil, fmt.Errorf("failed to parse state JSON: %w", err)
-	}
-
-	// Extract apiConfiguration object from state
-	apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
-	if !ok {
-		verboseLog("[DEBUG] No apiConfiguration found in state")
-		verboseLog("[DEBUG] Available keys in stateData: %v", getMapKeys(stateData))
-		return []cline.ApiProvider{}, nil
-	}
-
-	verboseLog("[DEBUG] apiConfiguration keys: %v", getMapKeys(apiConfig))
-
-	var configuredProviders []cline.ApiProvider
-
-	// Check for Cline provider (uses authentication instead of API key)
-	if IsAuthenticated(ctx) {
-		configuredProviders = append(configuredProviders, cline.ApiProvider_CLINE)
-		verboseLog("[DEBUG] Cline provider is authenticated")
-	}
-
-	// Check each BYO provider for API key presence
-	providersToCheck := []struct {
-		provider cline.ApiProvider
-		keyField string
-	}{
-		{cline.ApiProvider_ANTHROPIC, "apiKey"},
-		{cline.ApiProvider_OPENAI, "openAiApiKey"},
-		{cline.ApiProvider_OPENAI_NATIVE, "openAiNativeApiKey"},
-		{cline.ApiProvider_OPENROUTER, "openRouterApiKey"},
-		{cline.ApiProvider_XAI, "xaiApiKey"},
-		{cline.ApiProvider_BEDROCK, "awsAccessKey"},
-		{cline.ApiProvider_GEMINI, "geminiApiKey"},
-		{cline.ApiProvider_OLLAMA, "ollamaBaseUrl"}, // Ollama uses baseUrl instead of API key
-		{cline.ApiProvider_CEREBRAS, "cerebrasApiKey"},
-	}
-
-	for _, providerCheck := range providersToCheck {
-		verboseLog("[DEBUG] Checking for %s key: %s", getProviderDisplayName(providerCheck.provider), providerCheck.keyField)
-		if value, ok := apiConfig[providerCheck.keyField]; ok {
-			verboseLog("[DEBUG]   Found key, value type: %T, is empty: %v", value, value == "")
-			if str, ok := value.(string); ok && str != "" {
-				configuredProviders = append(configuredProviders, providerCheck.provider)
-				verboseLog("[DEBUG]   ✓ Provider %s is configured", getProviderDisplayName(providerCheck.provider))
-			}
-		} else {
-			verboseLog("[DEBUG]   Key %s not found", providerCheck.keyField)
-		}
-	}
-
-	verboseLog("[DEBUG] Total configured providers: %d", len(configuredProviders))
-	for _, p := range configuredProviders {
-		verboseLog("[DEBUG]   - %s", getProviderDisplayName(p))
-	}
-
-	return configuredProviders, nil
-}
-
-// getMapKeys returns the keys of a map for debugging
-func getMapKeys(m map[string]interface{}) []string {
-	keys := make([]string, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	return keys
-}

cli/pkg/cli/auth/update_api_configurations.go

@@ -1,509 +0,0 @@
-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"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/fieldmaskpb"
-)
-
-// updateApiConfigurationPartial is a helper that calls the gRPC method with optional verbose logging.
-// This replaces the Manager.UpdateApiConfigurationPartial method to keep auth-specific code in the auth package.
-func updateApiConfigurationPartial(ctx context.Context, manager *task.Manager, request *cline.UpdateApiConfigurationPartialRequest) error {
-	if global.Config.Verbose {
-		fmt.Println("[DEBUG] Updating API configuration (partial)")
-		if request.UpdateMask != nil && len(request.UpdateMask.Paths) > 0 {
-			fmt.Printf("[DEBUG] Field mask paths: %v\n", request.UpdateMask.Paths)
-		}
-		if request.ApiConfiguration != nil {
-			apiConfig := request.ApiConfiguration
-			if apiConfig.PlanModeApiProvider != nil {
-				fmt.Printf("[DEBUG] Plan mode provider: %s\n", *apiConfig.PlanModeApiProvider)
-			}
-			if apiConfig.ActModeApiProvider != nil {
-				fmt.Printf("[DEBUG] Act mode provider: %s\n", *apiConfig.ActModeApiProvider)
-			}
-		}
-	}
-
-	// Call the Models service to update API configuration
-	_, err := manager.GetClient().Models.UpdateApiConfigurationPartial(ctx, request)
-	if err != nil {
-		return fmt.Errorf("failed to update API configuration (partial): %w", err)
-	}
-
-	if global.Config.Verbose {
-		fmt.Println("[DEBUG] API configuration updated successfully (partial)")
-	}
-
-	return nil
-}
-
-// ProviderFields defines all the field names associated with a specific provider
-type ProviderFields struct {
-	APIKeyField            string // API key field name (e.g., "apiKey", "openAiApiKey")
-	PlanModeModelIDField   string // Plan mode model ID field (e.g., "planModeApiModelId")
-	ActModeModelIDField    string // Act mode model ID field (e.g., "actModeApiModelId")
-	PlanModeModelInfoField string // Plan mode model info field (optional, empty if not applicable)
-	ActModeModelInfoField  string // Act mode model info field (optional, empty if not applicable)
-	// Provider-specific additional model ID fields
-	PlanModeProviderSpecificModelIDField string // e.g., "planModeOpenRouterModelId"
-	ActModeProviderSpecificModelIDField  string // e.g., "actModeOpenRouterModelId"
-}
-
-// GetProviderFields returns the field mapping for a given provider
-func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
-	switch provider {
-	case cline.ApiProvider_ANTHROPIC:
-		return ProviderFields{
-			APIKeyField:          "apiKey",
-			PlanModeModelIDField: "planModeApiModelId",
-			ActModeModelIDField:  "actModeApiModelId",
-		}, nil
-
-	case cline.ApiProvider_OPENAI:
-		return ProviderFields{
-			APIKeyField:                          "openAiApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeProviderSpecificModelIDField: "planModeOpenAiModelId",
-			ActModeProviderSpecificModelIDField:  "actModeOpenAiModelId",
-		}, nil
-
-	case cline.ApiProvider_OPENROUTER:
-		return ProviderFields{
-			APIKeyField:                          "openRouterApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeModelInfoField:               "planModeOpenRouterModelInfo",
-			ActModeModelInfoField:                "actModeOpenRouterModelInfo",
-			PlanModeProviderSpecificModelIDField: "planModeOpenRouterModelId",
-			ActModeProviderSpecificModelIDField:  "actModeOpenRouterModelId",
-		}, nil
-
-	case cline.ApiProvider_XAI:
-		return ProviderFields{
-			APIKeyField:          "xaiApiKey",
-			PlanModeModelIDField: "planModeApiModelId",
-			ActModeModelIDField:  "actModeApiModelId",
-		}, nil
-
-	case cline.ApiProvider_BEDROCK:
-		return ProviderFields{
-			APIKeyField:                          "awsAccessKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeProviderSpecificModelIDField: "planModeAwsBedrockCustomModelBaseId",
-			ActModeProviderSpecificModelIDField:  "actModeAwsBedrockCustomModelBaseId",
-		}, nil
-
-	case cline.ApiProvider_GEMINI:
-		return ProviderFields{
-			APIKeyField:          "geminiApiKey",
-			PlanModeModelIDField: "planModeApiModelId",
-			ActModeModelIDField:  "actModeApiModelId",
-		}, nil
-
-	case cline.ApiProvider_OPENAI_NATIVE:
-		return ProviderFields{
-			APIKeyField:          "openAiNativeApiKey",
-			PlanModeModelIDField: "planModeApiModelId",
-			ActModeModelIDField:  "actModeApiModelId",
-		}, nil
-
-	case cline.ApiProvider_OLLAMA:
-		return ProviderFields{
-			APIKeyField:                          "ollamaBaseUrl",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeProviderSpecificModelIDField: "planModeOllamaModelId",
-			ActModeProviderSpecificModelIDField:  "actModeOllamaModelId",
-		}, nil
-
-	case cline.ApiProvider_CEREBRAS:
-		return ProviderFields{
-			APIKeyField:          "cerebrasApiKey",
-			PlanModeModelIDField: "planModeApiModelId",
-			ActModeModelIDField:  "actModeApiModelId",
-		}, nil
-
-	case cline.ApiProvider_CLINE:
-		return ProviderFields{
-			APIKeyField:                          "clineApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeModelInfoField:               "planModeOpenRouterModelInfo",
-			ActModeModelInfoField:                "actModeOpenRouterModelInfo",
-			PlanModeProviderSpecificModelIDField: "planModeOpenRouterModelId",
-			ActModeProviderSpecificModelIDField:  "actModeOpenRouterModelId",
-		}, nil
-
-	default:
-		return ProviderFields{}, fmt.Errorf("unsupported provider: %v", provider)
-	}
-}
-
-// ProviderUpdatesPartial defines optional fields for partial provider updates
-// Uses pointers to distinguish between "not provided" and "set to empty"
-type ProviderUpdatesPartial struct {
-	ModelID   *string     // New model ID (optional)
-	APIKey    *string     // New API key (optional)
-	ModelInfo interface{} // New model info (optional, provider-specific)
-}
-
-// GetModelIDFieldName returns the appropriate model ID field name for a provider and mode.
-// This helper centralizes the logic for determining whether to use provider-specific
-// or generic model ID fields.
-func GetModelIDFieldName(provider cline.ApiProvider, mode string) (string, error) {
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return "", err
-	}
-
-	if mode == "plan" {
-		// Use provider-specific field if available, otherwise use generic field
-		if fields.PlanModeProviderSpecificModelIDField != "" {
-			return fields.PlanModeProviderSpecificModelIDField, nil
-		}
-		return fields.PlanModeModelIDField, nil
-	}
-
-	// Act mode
-	if fields.ActModeProviderSpecificModelIDField != "" {
-		return fields.ActModeProviderSpecificModelIDField, nil
-	}
-	return fields.ActModeModelIDField, nil
-}
-
-// buildProviderFieldMask builds a list of camelCase field paths for the field mask.
-// When includeProviderEnums is true, the provider enum fields are included (for setting active provider).
-// When false, only the data fields are included (for configuring without activating).
-func buildProviderFieldMask(fields ProviderFields, includeAPIKey bool, includeModelID bool, includeModelInfo bool, includeProviderEnums bool) []string {
-	var fieldPaths []string
-
-	// Include provider enums if requested (used when setting active provider)
-	if includeProviderEnums {
-		fieldPaths = append(fieldPaths, "planModeApiProvider", "actModeApiProvider")
-	}
-
-	// Add API key field if requested
-	if includeAPIKey {
-		fieldPaths = append(fieldPaths, fields.APIKeyField)
-		// Special case: Bedrock also needs secret key
-		if fields.APIKeyField == "awsAccessKey" {
-			fieldPaths = append(fieldPaths, "awsSecretKey")
-		}
-	}
-
-	// Add model ID fields if requested
-	if includeModelID {
-		// Only include provider-specific fields if they exist, otherwise use generic fields
-		if fields.PlanModeProviderSpecificModelIDField != "" {
-			// Provider has specific fields - use ONLY those
-			fieldPaths = append(fieldPaths, fields.PlanModeProviderSpecificModelIDField)
-			fieldPaths = append(fieldPaths, fields.ActModeProviderSpecificModelIDField)
-		} else {
-			// Provider uses generic fields - update those
-			fieldPaths = append(fieldPaths, fields.PlanModeModelIDField)
-			fieldPaths = append(fieldPaths, fields.ActModeModelIDField)
-		}
-	}
-
-	// Add model info fields if requested and applicable
-	if includeModelInfo && fields.PlanModeModelInfoField != "" {
-		fieldPaths = append(fieldPaths, fields.PlanModeModelInfoField)
-		fieldPaths = append(fieldPaths, fields.ActModeModelInfoField)
-	}
-
-	return fieldPaths
-}
-
-// setAPIKeyField sets the appropriate API key field in the config based on the field name
-func setAPIKeyField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
-	switch fieldName {
-	case "apiKey":
-		apiConfig.ApiKey = value
-	case "openAiApiKey":
-		apiConfig.OpenAiApiKey = value
-	case "openAiNativeApiKey":
-		apiConfig.OpenAiNativeApiKey = value
-	case "openRouterApiKey":
-		apiConfig.OpenRouterApiKey = value
-	case "xaiApiKey":
-		apiConfig.XaiApiKey = value
-	case "awsAccessKey":
-		apiConfig.AwsAccessKey = value
-	case "geminiApiKey":
-		apiConfig.GeminiApiKey = value
-	case "ollamaBaseUrl":
-		apiConfig.OllamaBaseUrl = value
-	case "cerebrasApiKey":
-		apiConfig.CerebrasApiKey = value
-	case "clineApiKey":
-		apiConfig.ClineApiKey = value
-	}
-}
-
-// setProviderSpecificModelID sets the appropriate provider-specific model ID fields when possible
-func setProviderSpecificModelID(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
-	switch fieldName {
-	case "planModeOpenAiModelId":
-		apiConfig.PlanModeOpenAiModelId = value
-		apiConfig.ActModeOpenAiModelId = value
-	case "planModeOpenRouterModelId":
-		apiConfig.PlanModeOpenRouterModelId = value
-		apiConfig.ActModeOpenRouterModelId = value
-	case "planModeOllamaModelId":
-		apiConfig.PlanModeOllamaModelId = value
-		apiConfig.ActModeOllamaModelId = value
-	case "planModeAwsBedrockCustomModelBaseId":
-		apiConfig.PlanModeAwsBedrockCustomModelBaseId = value
-		apiConfig.ActModeAwsBedrockCustomModelBaseId = value
-	}
-}
-
-// AddProviderPartial configures a new provider with all necessary fields using partial updates.
-func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID string, apiKey string, modelInfo interface{}) error {
-	// Get field mapping for this provider
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return err
-	}
-
-	// Build a ModelsApiConfiguration with only the relevant provider fields set
-	apiConfig := &cline.ModelsApiConfiguration{}
-
-	// Set API key field
-	if apiKey != "" || fields.APIKeyField != "ollamaBaseUrl" {
-		setAPIKeyField(apiConfig, fields.APIKeyField, proto.String(apiKey))
-	}
-
-	// Set model ID fields
-	apiConfig.PlanModeApiModelId = proto.String(modelID)
-	apiConfig.ActModeApiModelId = proto.String(modelID)
-
-	// Set provider-specific model ID fields if applicable
-	if fields.PlanModeProviderSpecificModelIDField != "" {
-		setProviderSpecificModelID(apiConfig, fields.PlanModeProviderSpecificModelIDField, proto.String(modelID))
-	}
-
-	// Set model info if applicable and provided
-	if fields.PlanModeModelInfoField != "" && modelInfo != nil {
-		if openRouterInfo, ok := modelInfo.(*cline.OpenRouterModelInfo); ok {
-			apiConfig.PlanModeOpenRouterModelInfo = openRouterInfo
-			apiConfig.ActModeOpenRouterModelInfo = openRouterInfo
-		}
-	}
-
-	// Build field mask including all fields we're setting (without provider enums)
-	includeModelInfo := fields.PlanModeModelInfoField != "" && modelInfo != nil
-	fieldPaths := buildProviderFieldMask(fields, true, true, includeModelInfo, false)
-
-	// Create field mask
-	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
-
-	// Apply the partial update
-	request := &cline.UpdateApiConfigurationPartialRequest{
-		ApiConfiguration: apiConfig,
-		UpdateMask:       fieldMask,
-	}
-
-	if err := updateApiConfigurationPartial(ctx, manager, request); err != nil {
-		return fmt.Errorf("failed to update API configuration: %w", err)
-	}
-
-	return nil
-}
-
-// UpdateProviderPartial updates specific fields for an existing provider using partial updates.
-// If setAsActive is true, this will also set the provider as the active provider for both Plan and Act modes.
-func UpdateProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, updates ProviderUpdatesPartial, setAsActive bool) error {
-	// Get field mapping for this provider
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return err
-	}
-
-	// Build a ModelsApiConfiguration with only the fields being updated
-	apiConfig := &cline.ModelsApiConfiguration{}
-
-	// Set provider enum for BOTH Plan and Act modes if setAsActive is true
-	if setAsActive {
-		apiConfig.PlanModeApiProvider = &provider
-		apiConfig.ActModeApiProvider = &provider
-	}
-
-	// Track what we're updating for field mask
-	includeAPIKey := updates.APIKey != nil
-	includeModelID := updates.ModelID != nil
-	includeModelInfo := updates.ModelInfo != nil && fields.PlanModeModelInfoField != ""
-
-	// Update API key if provided
-	if updates.APIKey != nil {
-		setAPIKeyField(apiConfig, fields.APIKeyField, updates.APIKey)
-	}
-
-	// Update model ID if provided
-	if updates.ModelID != nil {
-		// Only set provider-specific fields if they exist, otherwise use generic fields
-		if fields.PlanModeProviderSpecificModelIDField != "" {
-			setProviderSpecificModelID(apiConfig, fields.PlanModeProviderSpecificModelIDField, updates.ModelID)
-		} else {
-			// Provider uses generic fields - set those
-			apiConfig.PlanModeApiModelId = updates.ModelID
-			apiConfig.ActModeApiModelId = updates.ModelID
-		}
-	}
-
-	// Update model info if provided
-	if updates.ModelInfo != nil && fields.PlanModeModelInfoField != "" {
-		if openRouterInfo, ok := updates.ModelInfo.(*cline.OpenRouterModelInfo); ok {
-			apiConfig.PlanModeOpenRouterModelInfo = openRouterInfo
-			apiConfig.ActModeOpenRouterModelInfo = openRouterInfo
-		}
-	}
-
-	// Build field mask for only the fields being updated
-	fieldPaths := buildProviderFieldMask(fields, includeAPIKey, includeModelID, includeModelInfo, setAsActive)
-
-	// Create field mask
-	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
-
-	// Apply the partial update
-	request := &cline.UpdateApiConfigurationPartialRequest{
-		ApiConfiguration: apiConfig,
-		UpdateMask:       fieldMask,
-	}
-
-	if err := updateApiConfigurationPartial(ctx, manager, request); err != nil {
-		return fmt.Errorf("failed to update API configuration: %w", err)
-	}
-
-	return nil
-}
-
-// RemoveProviderPartial removes a provider by clearing its API key using partial updates
-func RemoveProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider) error {
-	// Get field mapping for this provider
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return err
-	}
-
-	// Build an EMPTY ModelsApiConfiguration (or one with empty API key field)
-	// Fields in the mask without values will be cleared
-	apiConfig := &cline.ModelsApiConfiguration{}
-
-	// Build field mask with only the API key field(s)
-	// For Bedrock, include both access key and secret key
-	fieldPaths := []string{fields.APIKeyField}
-	if provider == cline.ApiProvider_BEDROCK {
-		fieldPaths = append(fieldPaths, "awsSecretKey")
-	}
-
-	// Create field mask
-	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
-
-	// Apply the partial update (clearing API key by including in mask without value)
-	request := &cline.UpdateApiConfigurationPartialRequest{
-		ApiConfiguration: apiConfig,
-		UpdateMask:       fieldMask,
-	}
-
-	if err := updateApiConfigurationPartial(ctx, manager, request); err != nil {
-		return fmt.Errorf("failed to update API configuration: %w", err)
-	}
-
-	return nil
-}
-
-// BedrockOptionalFields holds optional configuration fields for AWS Bedrock
-type BedrockOptionalFields struct {
-	SessionToken            *string // Optional: AWS session token for temporary credentials
-	Region                  *string // Optional: AWS region
-	UseCrossRegionInference *bool   // Optional: Enable cross-region inference
-	UseGlobalInference      *bool   // Optional: Use global inference endpoint
-	UsePromptCache          *bool   // Optional: Enable prompt caching
-	Authentication          *string // Optional: Authentication method
-	UseProfile              *bool   // Optional: Use AWS profile
-	Profile                 *string // Optional: AWS profile name
-	Endpoint                *string // Optional: Custom endpoint URL
-}
-
-// setBedrockOptionalFields sets optional Bedrock-specific fields in the API configuration
-func setBedrockOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *BedrockOptionalFields) {
-	if fields == nil {
-		return
-	}
-
-	if fields.SessionToken != nil {
-		apiConfig.AwsSessionToken = fields.SessionToken
-	}
-	if fields.Region != nil {
-		apiConfig.AwsRegion = fields.Region
-	}
-	if fields.UseCrossRegionInference != nil {
-		apiConfig.AwsUseCrossRegionInference = fields.UseCrossRegionInference
-	}
-	if fields.UseGlobalInference != nil {
-		apiConfig.AwsUseGlobalInference = fields.UseGlobalInference
-	}
-	if fields.UsePromptCache != nil {
-		apiConfig.AwsBedrockUsePromptCache = fields.UsePromptCache
-	}
-	if fields.Authentication != nil {
-		apiConfig.AwsAuthentication = fields.Authentication
-	}
-	if fields.UseProfile != nil {
-		apiConfig.AwsUseProfile = fields.UseProfile
-	}
-	if fields.Profile != nil {
-		apiConfig.AwsProfile = fields.Profile
-	}
-	if fields.Endpoint != nil {
-		apiConfig.AwsBedrockEndpoint = fields.Endpoint
-	}
-}
-
-// buildBedrockOptionalFieldMask builds field mask paths for Bedrock optional fields that have values
-func buildBedrockOptionalFieldMask(fields *BedrockOptionalFields) []string {
-	if fields == nil {
-		return nil
-	}
-
-	var fieldPaths []string
-
-	if fields.SessionToken != nil {
-		fieldPaths = append(fieldPaths, "awsSessionToken")
-	}
-	if fields.Region != nil {
-		fieldPaths = append(fieldPaths, "awsRegion")
-	}
-	if fields.UseCrossRegionInference != nil {
-		fieldPaths = append(fieldPaths, "awsUseCrossRegionInference")
-	}
-	if fields.UseGlobalInference != nil {
-		fieldPaths = append(fieldPaths, "awsUseGlobalInference")
-	}
-	if fields.UsePromptCache != nil {
-		fieldPaths = append(fieldPaths, "awsBedrockUsePromptCache")
-	}
-	if fields.Authentication != nil {
-		fieldPaths = append(fieldPaths, "awsAuthentication")
-	}
-	if fields.UseProfile != nil {
-		fieldPaths = append(fieldPaths, "awsUseProfile")
-	}
-	if fields.Profile != nil {
-		fieldPaths = append(fieldPaths, "awsProfile")
-	}
-	if fields.Endpoint != nil {
-		fieldPaths = append(fieldPaths, "awsBedrockEndpoint")
-	}
-
-	return fieldPaths
-}

cli/pkg/cli/auth/wizard_byo.go

@@ -1,676 +0,0 @@
-package auth
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-)
-
-// ProviderWizard handles the interactive provider configuration process
-type ProviderWizard struct {
-	ctx     context.Context
-	manager *task.Manager
-}
-
-// NewProviderWizard prepares a new provider configuration wizard
-func NewProviderWizard(ctx context.Context) (*ProviderWizard, error) {
-	// Create task manager using auth instance from context
-	manager, err := createTaskManager(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create task manager: %w", err)
-	}
-
-	return &ProviderWizard{
-		ctx:     ctx,
-		manager: manager,
-	}, nil
-}
-
-// showMainMenu displays the main provider configuration menu
-func (pw *ProviderWizard) showMainMenu() (string, error) {
-	var action string
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[string]().
-				Title("What would you like to do?").
-				Options(
-					huh.NewOption("Configure a new provider", "add"),
-					huh.NewOption("Change model for API provider", "change-model"),
-					huh.NewOption("Remove a provider", "remove"),
-					huh.NewOption("List configured providers", "list"),
-					huh.NewOption("Return to main auth menu", "back"),
-				).
-				Value(&action),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return "", fmt.Errorf("failed to get menu choice: %w", err)
-	}
-
-	return action, nil
-}
-
-// Run runs the provider configuration wizard
-func (pw *ProviderWizard) Run() error {
-
-	for {
-		action, err := pw.showMainMenu()
-		if err != nil {
-			return err
-		}
-
-		switch action {
-		case "add":
-			if err := pw.handleAddProvider(); err != nil {
-				return err
-			}
-		case "change-model":
-			if err := pw.handleChangeModel(); err != nil {
-				return err
-			}
-		case "remove":
-			if err := pw.handleRemoveProvider(); err != nil {
-				return err
-			}
-		case "list":
-			if err := pw.handleListProviders(); err != nil {
-				return err
-			}
-		case "back":
-			// Return to main auth menu
-			return HandleAuthMenuNoArgs(pw.ctx)
-		}
-		fmt.Println()
-	}
-}
-
-// "Add a new provider" > handleAddProvider
-func (pw *ProviderWizard) handleAddProvider() error {
-	// Step 1: Select provider
-	provider, err := SelectBYOProvider()
-	if err != nil {
-		if strings.Contains(err.Error(), "cancelled") {
-			return nil
-		}
-		return fmt.Errorf("provider selection failed: %w", err)
-	}
-
-	// Step 2: Special handling for Bedrock provider
-	if provider == cline.ApiProvider_BEDROCK {
-		return pw.handleAddBedrockProvider()
-	}
-
-	// Step 3: Get API key first (for non-Bedrock providers)
-	apiKey, err := PromptForAPIKey(provider)
-	if err != nil {
-		return fmt.Errorf("failed to get API key: %w", err)
-	}
-
-	// Step 4: Try to fetch models and let user select (with fallback to manual entry for providers that don't support fetch)
-	modelID, modelInfo, err := pw.selectModel(provider, apiKey)
-	if err != nil {
-		return fmt.Errorf("model selection failed: %w", err)
-	}
-
-	// Step 5: Apply configuration using AddProviderPartial
-	if err := AddProviderPartial(pw.ctx, pw.manager, provider, modelID, apiKey, modelInfo); err != nil {
-		return fmt.Errorf("failed to save configuration: %w", err)
-	}
-
-	if err := setWelcomeViewCompleted(pw.ctx, pw.manager); err != nil {
-		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
-	}
-
-	fmt.Println("✓ Provider configured successfully!")
-	return nil
-}
-
-// handleAddBedrockProvider handles the special case of adding Bedrock provider with its multi-field form
-func (pw *ProviderWizard) handleAddBedrockProvider() error {
-	// Step 1: Get Bedrock configuration (all credentials and optional fields)
-	config, err := PromptForBedrockConfig(pw.ctx, pw.manager)
-	if err != nil {
-		if strings.Contains(err.Error(), "user declined profile authentication") {
-			return nil
-		}
-		return fmt.Errorf("failed to get Bedrock configuration: %w", err)
-	}
-
-	// Step 2: Select model
-	modelID, modelInfo, err := pw.selectModel(cline.ApiProvider_BEDROCK, "")
-	if err != nil {
-		return fmt.Errorf("model selection failed: %w", err)
-	}
-
-	// Step 3: Apply Bedrock configuration
-	if err := ApplyBedrockConfig(pw.ctx, pw.manager, config, modelID, modelInfo); err != nil {
-		return fmt.Errorf("failed to save Bedrock configuration: %w", err)
-	}
-
-	if err := setWelcomeViewCompleted(pw.ctx, pw.manager); err != nil {
-		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
-	}
-
-	fmt.Println("✓ Bedrock provider configured successfully!")
-	return nil
-}
-
-// handleListProviders retrieves and displays configured providers
-func (pw *ProviderWizard) handleListProviders() error {
-	result, err := GetProviderConfigurations(pw.ctx, pw.manager)
-	if err != nil {
-		return fmt.Errorf("failed to retrieve provider configurations: %w", err)
-	}
-
-	output := FormatProviderList(result)
-	fmt.Println(output)
-
-	return nil
-}
-
-// selectModel attempts to fetch available models and let user select, or falls back to manual entry
-func (pw *ProviderWizard) selectModel(provider cline.ApiProvider, apiKey string) (string, interface{}, error) {
-	// For providers that support model fetching, try to fetch and display models
-	canFetchModels := pw.supportsModelFetching(provider)
-
-	if canFetchModels {
-		fmt.Println("Fetching available models...")
-		models, modelInfoMap, err := pw.fetchModelsForProvider(provider, apiKey)
-
-		if err != nil {
-			fmt.Println("\n⚠ Unable to fetch model list from the provider. Please enter the model ID manually instead.")
-			if global.Config.Verbose {
-				fmt.Printf("   Error details: %v\n", err)
-			}
-			return pw.manualModelEntry(provider)
-		}
-
-		if len(models) == 0 {
-			fmt.Println("\n⚠ No models found from the provider. Please enter the model ID manually instead.")
-			return pw.manualModelEntry(provider)
-		}
-
-		// Let user select from available models (includes manual entry option)
-		modelID, err := pw.selectFromAvailableModels(models)
-		if err != nil {
-			return "", nil, fmt.Errorf("model selection failed: %w", err)
-		}
-
-		// Check if user chose manual entry
-		const manualEntryKey = "__MANUAL_ENTRY__"
-		if modelID == manualEntryKey {
-			return pw.manualModelEntry(provider)
-		}
-
-		// Get the model info for the selected model
-		var modelInfo interface{}
-		if modelInfoMap != nil {
-			modelInfo = modelInfoMap[modelID]
-		}
-
-		return modelID, modelInfo, nil
-	}
-
-	// For providers without model fetching support, use manual entry
-	return pw.manualModelEntry(provider)
-}
-
-// supportsModelFetching returns true if the provider supports fetching models
-func (pw *ProviderWizard) supportsModelFetching(provider cline.ApiProvider) bool {
-	return SupportsBYOModelFetching(provider)
-}
-
-// fetchModelsForProvider fetches models for a given provider
-// Supports both dynamic API fetching (OpenRouter, OpenAI, Ollama) and static model lists (Anthropic, Bedrock, Gemini, X AI)
-func (pw *ProviderWizard) fetchModelsForProvider(provider cline.ApiProvider, apiKey string) ([]string, map[string]interface{}, error) {
-	// Try dynamic/remote model fetching first
-	switch provider {
-	case cline.ApiProvider_OPENROUTER:
-		models, err := FetchOpenRouterModels(pw.ctx, pw.manager)
-		if err != nil {
-			return nil, nil, err
-		}
-		interfaceMap := ConvertOpenRouterModelsToInterface(models)
-		return ConvertModelsMapToSlice(interfaceMap), interfaceMap, nil
-
-	case cline.ApiProvider_OPENAI:
-		// For OpenAI, we need to pass the base URL and API key
-		baseURL := "https://api.openai.com/v1" // Default OpenAI API base URL
-		modelIDs, err := FetchOpenAiModels(pw.ctx, pw.manager, baseURL, apiKey)
-		if err != nil {
-			return nil, nil, err
-		}
-		// OpenAI returns just model IDs without additional info, so modelInfo map is nil
-		return modelIDs, nil, nil
-
-	case cline.ApiProvider_OLLAMA:
-		// For Ollama, apiKey actually contains the base URL (or empty for default)
-		baseURL := apiKey // The "API key" field for Ollama is actually the base URL
-		modelIDs, err := FetchOllamaModels(pw.ctx, pw.manager, baseURL)
-		if err != nil {
-			return nil, nil, err
-		}
-		// Ollama returns just model IDs without additional info, so modelInfo map is nil
-		return modelIDs, nil, nil
-	}
-
-	// Fall back to static models for providers that don't support dynamic fetching
-	if SupportsStaticModelList(provider) {
-		modelIDs, _, err := FetchStaticModels(provider)
-		if err != nil {
-			return nil, nil, err
-		}
-		// Static models don't have detailed info maps for now, so modelInfo map is nil
-		return modelIDs, nil, nil
-	}
-
-	return nil, nil, fmt.Errorf("model fetching not supported for provider: %v", provider)
-}
-
-// selectFromAvailableModels displays available models and lets user select one.
-// Includes an option to enter a model ID manually in case the desired model isn't listed.
-func (pw *ProviderWizard) selectFromAvailableModels(models []string) (string, error) {
-	if len(models) == 0 {
-		return "", fmt.Errorf("no models available")
-	}
-
-	// Add a special "manual entry" option at the end
-	const manualEntryKey = "__MANUAL_ENTRY__"
-
-	// Use model ID as the value (not index)
-	var selectedModel string
-	options := make([]huh.Option[string], len(models)+1)
-	for i, model := range models {
-		options[i] = huh.NewOption(model, model)
-	}
-	// Add manual entry option at the end
-	options[len(models)] = huh.NewOption("Enter model ID manually...", manualEntryKey)
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[string]().
-				Title("Select a model").
-				Options(options...).
-				Height(calculateSelectHeight()).
-				Filtering(true).
-				Value(&selectedModel),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return "", fmt.Errorf("failed to select model: %w", err)
-	}
-
-	// If user selected manual entry, return special key to trigger manual input
-	if selectedModel == manualEntryKey {
-		return manualEntryKey, nil
-	}
-
-	return selectedModel, nil
-}
-
-// manualModelEntry prompts user to manually enter a model ID.
-// Returns the model ID and an error. The modelInfo is always nil for manual entry.
-func (pw *ProviderWizard) manualModelEntry(provider cline.ApiProvider) (string, interface{}, error) {
-	var modelID string
-	modelPlaceholder := GetBYOProviderPlaceholder(provider)
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewInput().
-				Title("Model ID").
-				Placeholder(modelPlaceholder).
-				Value(&modelID).
-				Validate(func(s string) error {
-					// Trim whitespace and validate
-					trimmed := strings.TrimSpace(s)
-					if trimmed == "" {
-						return fmt.Errorf("model ID cannot be empty")
-					}
-					return nil
-				}),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return "", nil, fmt.Errorf("failed to get model ID: %w", err)
-	}
-
-	// Trim whitespace from the final value
-	modelID = strings.TrimSpace(modelID)
-
-	// modelInfo is always nil for manual entry
-	return modelID, nil, nil
-}
-
-// handleChangeModel allows changing the model for any configured provider
-func (pw *ProviderWizard) handleChangeModel() error {
-	// Step 1: Get current provider configurations
-	result, err := GetProviderConfigurations(pw.ctx, pw.manager)
-	if err != nil {
-		return fmt.Errorf("failed to retrieve provider configurations: %w", err)
-	}
-
-	// Step 2: Get all configured providers with models
-	readyProviders := result.GetAllReadyProviders()
-
-	// Filter out Cline provider (it has its own model changer in the main menu)
-	var configurableProviders []*ProviderDisplay
-	for _, provider := range readyProviders {
-		if provider.Provider != cline.ApiProvider_CLINE {
-			configurableProviders = append(configurableProviders, provider)
-		}
-	}
-
-	// Step 3: Check if there are any configurable providers
-	if len(configurableProviders) == 0 {
-		fmt.Println("\nNo configurable providers found.")
-		fmt.Println("Note: Cline provider has its own model selection in the main menu.")
-		return nil
-	}
-
-	// Step 4: Let user select which provider to change the model for
-	var selectedIndex int
-	options := make([]huh.Option[int], len(configurableProviders)+1)
-	for i, providerDisplay := range configurableProviders {
-		displayName := fmt.Sprintf("%s (current: %s)",
-			getProviderDisplayName(providerDisplay.Provider),
-			providerDisplay.ModelID)
-		options[i] = huh.NewOption(displayName, i)
-	}
-	options[len(configurableProviders)] = huh.NewOption("(Cancel)", -1)
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[int]().
-				Title("Select provider to change model for").
-				Options(options...).
-				Value(&selectedIndex),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return fmt.Errorf("failed to select provider: %w", err)
-	}
-
-	if selectedIndex == -1 {
-		return nil
-	}
-
-	selectedProvider := configurableProviders[selectedIndex]
-	provider := selectedProvider.Provider
-
-	fmt.Printf("\nChanging model for %s\n", getProviderDisplayName(provider))
-	fmt.Printf("Current model: %s\n\n", selectedProvider.ModelID)
-
-	// Step 5: Retrieve API key if needed for model fetching
-	var apiKey string
-	if pw.supportsModelFetching(provider) {
-		// For providers that support fetching, we need to retrieve the API key from state
-		state, err := pw.manager.GetClient().State.GetLatestState(pw.ctx, &cline.EmptyRequest{})
-		if err != nil {
-			return fmt.Errorf("failed to get state: %w", err)
-		}
-
-		var stateData map[string]interface{}
-		if err := json.Unmarshal([]byte(state.StateJson), &stateData); err != nil {
-			return fmt.Errorf("failed to parse state JSON: %w", err)
-		}
-
-		apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
-		if !ok {
-			return fmt.Errorf("no API configuration found in state")
-		}
-
-		apiKey = getProviderAPIKeyFromState(apiConfig, provider)
-		if apiKey == "" {
-			return fmt.Errorf("no API key found for provider %s", getProviderDisplayName(provider))
-		}
-	}
-
-	modelID, modelInfo, err := pw.selectModel(provider, apiKey)
-	if err != nil {
-		return fmt.Errorf("model selection failed: %w", err)
-	}
-
-	// Step 6: Apply the model change (for both Plan and Act modes)
-	if err := pw.applyModelChange(provider, modelID, modelInfo); err != nil {
-		return fmt.Errorf("failed to apply model change: %w", err)
-	}
-
-	fmt.Printf("✓ Model changed successfully to: %s\n", modelID)
-	fmt.Println("  (Applied to both Plan and Act modes)")
-	return nil
-}
-
-// applyModelChange applies a model change for both Plan and Act modes using UpdateProviderPartial
-func (pw *ProviderWizard) applyModelChange(provider cline.ApiProvider, modelID string, modelInfo interface{}) error {
-	updates := ProviderUpdatesPartial{
-		ModelID:   &modelID,
-		ModelInfo: modelInfo,
-	}
-
-	return UpdateProviderPartial(pw.ctx, pw.manager, provider, updates, false)
-}
-
-// SwitchToBYOProvider switches to a BYO provider that's already configured.
-// It retrieves the existing model configuration and sets it as the active provider for both Plan and Act modes.
-func SwitchToBYOProvider(ctx context.Context, manager *task.Manager, provider cline.ApiProvider) error {
-	// Get the current state to retrieve the model ID and model info for this provider
-	state, err := manager.GetClient().State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get state: %w", err)
-	}
-
-	// Parse state JSON
-	var stateData map[string]interface{}
-	if err := json.Unmarshal([]byte(state.StateJson), &stateData); err != nil {
-		return fmt.Errorf("failed to parse state JSON: %w", err)
-	}
-
-	// Extract apiConfiguration
-	apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
-	if !ok {
-		return fmt.Errorf("no API configuration found in state")
-	}
-
-	// Get the model ID for the selected provider
-	modelID := getProviderModelIDFromState(apiConfig, provider)
-	if modelID == "" {
-		return fmt.Errorf("no model configured for provider %s", getProviderDisplayName(provider))
-	}
-
-	// Get model info if available (for OpenRouter/Cline)
-	var modelInfo interface{}
-	if provider == cline.ApiProvider_OPENROUTER || provider == cline.ApiProvider_CLINE {
-		if modelInfoData, ok := apiConfig["planModeOpenRouterModelInfo"].(map[string]interface{}); ok {
-			modelInfo = convertMapToOpenRouterModelInfo(modelInfoData)
-		}
-	}
-
-	// Use UpdateProviderPartial to switch to this provider
-	updates := ProviderUpdatesPartial{
-		ModelID:   &modelID,
-		ModelInfo: modelInfo,
-	}
-
-	if err := UpdateProviderPartial(ctx, manager, provider, updates, true); err != nil {
-		return fmt.Errorf("failed to switch provider: %w", err)
-	}
-
-	verboseLog("✓ Switched to %s\n", getProviderDisplayName(provider))
-	verboseLog("  Using model: %s\n", modelID)
-
-	return HandleAuthMenuNoArgs(ctx)
-}
-
-// getProviderModelIDFromState retrieves the model ID for a specific provider from state
-func getProviderModelIDFromState(stateData map[string]interface{}, provider cline.ApiProvider) string {
-	modelKey, err := GetModelIDFieldName(provider, "plan")
-	if err != nil {
-		return ""
-	}
-
-	if modelID, ok := stateData[modelKey].(string); ok {
-		return modelID
-	}
-
-	return ""
-}
-
-// getProviderAPIKeyFromState retrieves the API key for a specific provider from state
-func getProviderAPIKeyFromState(stateData map[string]interface{}, provider cline.ApiProvider) string {
-	fields, err := GetProviderFields(provider)
-	if err != nil {
-		return ""
-	}
-
-	if apiKey, ok := stateData[fields.APIKeyField].(string); ok {
-		return apiKey
-	}
-
-	return ""
-}
-
-// convertMapToOpenRouterModelInfo converts a map to OpenRouterModelInfo
-func convertMapToOpenRouterModelInfo(data map[string]interface{}) *cline.OpenRouterModelInfo {
-	info := &cline.OpenRouterModelInfo{}
-
-	if val, ok := data["description"].(string); ok {
-		info.Description = &val
-	}
-	if val, ok := data["contextWindow"].(float64); ok {
-		contextWindow := int64(val)
-		info.ContextWindow = &contextWindow
-	}
-	if val, ok := data["maxTokens"].(float64); ok {
-		maxTokens := int64(val)
-		info.MaxTokens = &maxTokens
-	}
-	if val, ok := data["inputPrice"].(float64); ok {
-		info.InputPrice = &val
-	}
-	if val, ok := data["outputPrice"].(float64); ok {
-		info.OutputPrice = &val
-	}
-	if val, ok := data["cacheWritesPrice"].(float64); ok {
-		info.CacheWritesPrice = &val
-	}
-	if val, ok := data["cacheReadsPrice"].(float64); ok {
-		info.CacheReadsPrice = &val
-	}
-	if val, ok := data["supportsImages"].(bool); ok {
-		info.SupportsImages = &val
-	}
-	if val, ok := data["supportsPromptCache"].(bool); ok {
-		info.SupportsPromptCache = val
-	}
-
-	return info
-}
-
-// handleRemoveProvider allows removing a configured provider by clearing its API key
-func (pw *ProviderWizard) handleRemoveProvider() error {
-	// Step 1: Get current provider configurations
-	result, err := GetProviderConfigurations(pw.ctx, pw.manager)
-	if err != nil {
-		return fmt.Errorf("failed to retrieve provider configurations: %w", err)
-	}
-
-	// Step 2: Get all ready providers
-	readyProviders := result.GetAllReadyProviders()
-
-	// Filter out Cline provider (uses account auth, not API keys)
-	var removableProviders []*ProviderDisplay
-	for _, provider := range readyProviders {
-		if provider.Provider != cline.ApiProvider_CLINE {
-			removableProviders = append(removableProviders, provider)
-		}
-	}
-
-	// Step 3: Check if there are providers to remove
-	if len(removableProviders) == 0 {
-		fmt.Println("\nNo providers available to remove.")
-		fmt.Println("Note: Cline provider cannot be removed via this menu.")
-		return nil
-	}
-
-	// Step 4: Display selection menu
-	var selectedIndex int
-	options := make([]huh.Option[int], len(removableProviders))
-	for i, provider := range removableProviders {
-		// Mark active provider
-		displayName := getProviderDisplayName(provider.Provider)
-		if result.ActProvider != nil && provider.Provider == result.ActProvider.Provider {
-			displayName += " (ACTIVE)"
-		}
-		options[i] = huh.NewOption(displayName, i)
-	}
-
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[int]().
-				Title("Select provider to remove").
-				Options(options...).
-				Value(&selectedIndex),
-		),
-	)
-
-	if err := form.Run(); err != nil {
-		return fmt.Errorf("failed to select provider: %w", err)
-	}
-
-	selectedProvider := removableProviders[selectedIndex]
-
-	// Step 5: Check if trying to remove the active provider
-	if result.ActProvider != nil && selectedProvider.Provider == result.ActProvider.Provider {
-		fmt.Printf("\nCannot remove %s because it is currently active.\n", getProviderDisplayName(selectedProvider.Provider))
-		fmt.Println("Please switch to a different provider first, then try again.")
-		return nil
-	}
-
-	// Step 6: Confirm removal
-	var confirm bool
-	confirmForm := huh.NewForm(
-		huh.NewGroup(
-			huh.NewConfirm().
-				Title(fmt.Sprintf("Are you sure you want to remove %s?", getProviderDisplayName(selectedProvider.Provider))).
-				Description("This will clear the API key but preserve the model configuration.").
-				Value(&confirm),
-		),
-	)
-
-	if err := confirmForm.Run(); err != nil {
-		return fmt.Errorf("failed to get confirmation: %w", err)
-	}
-
-	if !confirm {
-		fmt.Println("Removal cancelled.")
-		return nil
-	}
-
-	// Step 7: Clear the API key for the selected provider
-	if err := pw.clearProviderAPIKey(selectedProvider.Provider); err != nil {
-		return fmt.Errorf("failed to remove provider: %w", err)
-	}
-
-	fmt.Printf("\n✓ %s removed successfully\n", getProviderDisplayName(selectedProvider.Provider))
-	return nil
-}
-
-// clearProviderAPIKey clears the API key field for a specific provider using RemoveProviderPartial
-func (pw *ProviderWizard) clearProviderAPIKey(provider cline.ApiProvider) error {
-	return RemoveProviderPartial(pw.ctx, pw.manager, provider)
-}
-
-func setWelcomeViewCompleted(ctx context.Context, manager *task.Manager) error {
-	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
-	return err
-}

cli/pkg/cli/auth/wizard_byo_bedrock.go

@@ -1,193 +0,0 @@
-package auth
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/fieldmaskpb"
-)
-
-// BedrockConfig holds all AWS Bedrock-specific configuration fields
-type BedrockConfig struct {
-	// Profile authentication fields
-	UseProfile              bool   // Always true for successful config
-	Profile                 string // Optional: AWS profile name (empty = default)
-	Region                  string // Required: AWS region
-	Endpoint                string // Optional: Custom VPC endpoint URL
-	
-	// Optional features
-	UseCrossRegionInference bool   // Optional: Enable cross-region inference
-	UseGlobalInference      bool   // Optional: Use global inference endpoint
-	UsePromptCache          bool   // Optional: Enable prompt caching
-	
-	// Authentication method (always "profile")
-	Authentication          string // Always set to "profile"
-	
-	// Legacy fields (no longer used in profile-only flow)
-	AccessKey               string // No longer used
-	SecretKey               string // No longer used
-	SessionToken            string // No longer used
-}
-
-// PromptForBedrockConfig displays a profile-first authentication form for Bedrock configuration
-func PromptForBedrockConfig(ctx context.Context, manager *task.Manager) (*BedrockConfig, error) {
-	config := &BedrockConfig{}
-
-	// First, ask if user wants to use AWS profile authentication
-	var useProfile bool
-	profileQuestion := huh.NewForm(
-		huh.NewGroup(
-			huh.NewConfirm().
-				Title("Do you want to use an AWS profile for authentication?").
-				Description("AWS profiles are managed via 'aws configure'").
-				Value(&useProfile).
-				Affirmative("Yes").
-				Negative("No").
-				Inline(true),
-		),
-	)
-
-	if err := profileQuestion.Run(); err != nil {
-		return nil, fmt.Errorf("failed to get authentication method: %w", err)
-	}
-
-	// If user declines profile authentication, show message and return error
-	if !useProfile {
-		fmt.Println("\nAWS profile authentication is currently the only supported method in the CLI.")
-		fmt.Println("Please configure an AWS profile using 'aws configure' and try again.")
-		return nil, fmt.Errorf("user declined profile authentication")
-	}
-
-	// User wants profile auth - collect profile configuration
-	config.UseProfile = true
-	config.Authentication = "profile"
-
-	// Collect profile name, region, and optional settings
-	configForm := huh.NewForm(
-		huh.NewGroup(
-			huh.NewInput().
-				Title("AWS Profile Name (optional, press Enter for default profile)").
-				Value(&config.Profile).
-				Description("Leave empty to use default AWS profile"),
-
-			huh.NewInput().
-				Title("AWS Region (required, e.g., us-east-1)").
-				Value(&config.Region).
-				Validate(func(s string) error {
-					if strings.TrimSpace(s) == "" {
-						return fmt.Errorf("AWS Region is required")
-					}
-					return nil
-				}),
-
-			huh.NewInput().
-				Title("Custom VPC Endpoint URL (optional)").
-				Value(&config.Endpoint).
-				Description("Press Enter to skip"),
-
-			huh.NewConfirm().
-				Title("Enable Prompt Cache?             ").
-				Value(&config.UsePromptCache).
-				Affirmative("Yes").
-				Negative("No").
-				Inline(true),
-
-			huh.NewConfirm().
-				Title("Enable Cross-Region Inference?   ").
-				Value(&config.UseCrossRegionInference).
-				Affirmative("Yes").
-				Negative("No").
-				Inline(true),
-
-			huh.NewConfirm().
-				Title("Use Global Inference Endpoint?   ").
-				Value(&config.UseGlobalInference).
-				Affirmative("Yes").
-				Negative("No").
-				Inline(true),
-		),
-	)
-
-	if err := configForm.Run(); err != nil {
-		return nil, fmt.Errorf("failed to get Bedrock configuration: %w", err)
-	}
-
-	// Trim whitespace from string fields
-	config.Profile = strings.TrimSpace(config.Profile)
-	config.Region = strings.TrimSpace(config.Region)
-	config.Endpoint = strings.TrimSpace(config.Endpoint)
-
-	return config, nil
-}
-
-// ApplyBedrockConfig applies Bedrock configuration using partial updates (profile-only)
-func ApplyBedrockConfig(ctx context.Context, manager *task.Manager, config *BedrockConfig, modelID string, modelInfo interface{}) error {
-	// Build the API configuration with all Bedrock fields
-	apiConfig := &cline.ModelsApiConfiguration{}
-
-	// Set model ID fields
-	apiConfig.PlanModeApiModelId = proto.String(modelID)
-	apiConfig.ActModeApiModelId = proto.String(modelID)
-	apiConfig.PlanModeAwsBedrockCustomModelBaseId = proto.String(modelID)
-	apiConfig.ActModeAwsBedrockCustomModelBaseId = proto.String(modelID)
-
-	// Set profile authentication fields (always required)
-	optionalFields := &BedrockOptionalFields{}
-	optionalFields.Authentication = proto.String("profile")
-	optionalFields.UseProfile = proto.Bool(true)
-	optionalFields.Region = proto.String(config.Region)
-
-	// Set profile name (can be empty for default profile)
-	if config.Profile != "" {
-		optionalFields.Profile = proto.String(config.Profile)
-	}
-
-	// Set optional fields if provided
-	if config.Endpoint != "" {
-		optionalFields.Endpoint = proto.String(config.Endpoint)
-	}
-	if config.UseCrossRegionInference {
-		optionalFields.UseCrossRegionInference = proto.Bool(true)
-	}
-	if config.UseGlobalInference {
-		optionalFields.UseGlobalInference = proto.Bool(true)
-	}
-	if config.UsePromptCache {
-		optionalFields.UsePromptCache = proto.Bool(true)
-	}
-
-	// Apply all fields to the config
-	setBedrockOptionalFields(apiConfig, optionalFields)
-
-	// Build field mask including all fields we're setting (excluding access keys)
-	fieldPaths := []string{
-		"planModeApiModelId",
-		"actModeApiModelId",
-		"planModeAwsBedrockCustomModelBaseId",
-		"actModeAwsBedrockCustomModelBaseId",
-	}
-
-	// Add profile authentication field paths
-	optionalPaths := buildBedrockOptionalFieldMask(optionalFields)
-	fieldPaths = append(fieldPaths, optionalPaths...)
-
-	// Create field mask
-	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
-
-	// Apply the partial update
-	request := &cline.UpdateApiConfigurationPartialRequest{
-		ApiConfiguration: apiConfig,
-		UpdateMask:       fieldMask,
-	}
-
-	if err := updateApiConfigurationPartial(ctx, manager, request); err != nil {
-		return fmt.Errorf("failed to apply Bedrock configuration: %w", err)
-	}
-
-	return nil
-}

cli/pkg/cli/clerror/cline_error.go

@@ -1,187 +0,0 @@
-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 ""
-}

cli/pkg/cli/config.go

@@ -1,149 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/cline/cli/pkg/cli/config"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/spf13/cobra"
-)
-
-var configManager *config.Manager
-
-func ensureConfigManager(ctx context.Context, address string) error {
-	if configManager == nil || (address != "" && configManager.GetCurrentInstance() != address) {
-		var err error
-		var instanceAddress string
-
-		if address != "" {
-			// Ensure instance exists at the specified address
-			if err := ensureInstanceAtAddress(ctx, address); err != nil {
-				return fmt.Errorf("failed to ensure instance at address %s: %w", address, err)
-			}
-			configManager, err = config.NewManager(ctx, address)
-			instanceAddress = address
-		} else {
-			// Ensure default instance exists
-			if err := global.EnsureDefaultInstance(ctx); err != nil {
-				return fmt.Errorf("failed to ensure default instance: %w", err)
-			}
-			configManager, err = config.NewManager(ctx, "")
-			if err == nil {
-				instanceAddress = configManager.GetCurrentInstance()
-			}
-		}
-
-		if err != nil {
-			return fmt.Errorf("failed to create config manager: %w", err)
-		}
-
-		// Always set the instance we're using as the default
-		registry := global.Clients.GetRegistry()
-		if err := registry.SetDefaultInstance(instanceAddress); err != nil {
-			// Log warning but don't fail - this is not critical
-			fmt.Printf("Warning: failed to set default instance: %v\n", err)
-		}
-	}
-	return nil
-}
-
-func NewConfigCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "config",
-		Aliases: []string{"c"},
-		Short:   "Manage Cline configuration",
-		Long:    `Set and manage global Cline configuration variables.`,
-	}
-
-	cmd.AddCommand(newConfigListCommand())
-	cmd.AddCommand(newConfigGetCommand())
-	cmd.AddCommand(setCommand())
-
-	return cmd
-}
-
-func newConfigGetCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "get <key>",
-		Aliases: []string{"g"},
-		Short:   "Get a specific configuration value",
-		Long:    `Get the value of a specific configuration setting. Supports nested keys using dot notation (e.g., auto-approval-settings.actions.read-files).`,
-		Args:    cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-			key := args[0]
-
-			// Ensure config manager
-			if err := ensureConfigManager(ctx, address); err != nil {
-				return err
-			}
-
-			// Get the setting
-			return configManager.GetSetting(ctx, key)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}
-
-func newConfigListCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"l"},
-		Short:   "List all configuration settings",
-		Long:    `List all configuration settings from the Cline instance.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Ensure config manager
-			if err := ensureConfigManager(ctx, address); err != nil {
-				return err
-			}
-
-			// List settings
-			return configManager.ListSettings(ctx)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}
-
-func setCommand() *cobra.Command {
-	var address string
-
-	cmd := &cobra.Command{
-		Use:     "set <key=value> [key=value...]",
-		Aliases: []string{"s"},
-		Short:   "Set configuration variables",
-		Long:    `Set one or more global configuration variables using key=value format.`,
-		Args:    cobra.MinimumNArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Parse using existing task parser
-			settings, secrets, err := task.ParseTaskSettings(args)
-			if err != nil {
-				return fmt.Errorf("failed to parse settings: %w", err)
-			}
-
-			// Ensure config manager
-			if err := ensureConfigManager(ctx, address); err != nil {
-				return err
-			}
-
-			// Update settings
-			return configManager.UpdateSettings(ctx, settings, secrets)
-		},
-	}
-
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	return cmd
-}

cli/pkg/cli/config/manager.go

@@ -1,208 +0,0 @@
-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
-}

cli/pkg/cli/config/settings_renderer.go

@@ -1,198 +0,0 @@
-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, maxRequests, enableNotifications, favorites)
-			fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
-		}
-	}
-
-	return nil
-}

cli/pkg/cli/display/ansi.go

@@ -1,27 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"os"
-
-	"golang.org/x/term"
-)
-
-func isTTY() bool {
-	return term.IsTerminal(int(os.Stdout.Fd()))
-}
-
-func ClearLine() {
-	if !isTTY() {
-		return
-	}
-	fmt.Print("\r\033[K")
-}
-
-// ClearToEnd clears from cursor to end of screen
-func ClearToEnd() {
-	if !isTTY() {
-		return
-	}
-	fmt.Print("\033[J")
-}

cli/pkg/cli/display/deduplicator.go

@@ -1,95 +0,0 @@
-package display
-
-import (
-	"crypto/md5"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// MessageDeduplicator handles message deduplication to prevent duplicate displays
-type MessageDeduplicator struct {
-	mu            sync.RWMutex
-	seenMessages  map[string]time.Time
-	maxAge        time.Duration
-	cleanupTicker *time.Ticker
-}
-
-// NewMessageDeduplicator creates a new message deduplicator
-func NewMessageDeduplicator() *MessageDeduplicator {
-	d := &MessageDeduplicator{
-		seenMessages:  make(map[string]time.Time),
-		maxAge:        5 * time.Minute,                 // Keep messages for 5 minutes
-		cleanupTicker: time.NewTicker(1 * time.Minute), // Cleanup every minute
-	}
-
-	// Start cleanup goroutine
-	go d.cleanup()
-
-	return d
-}
-
-// IsDuplicate checks if a message is a duplicate
-func (d *MessageDeduplicator) IsDuplicate(msg *types.ClineMessage) bool {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	// Create a hash of the message content
-	hash := d.hashMessage(msg)
-
-	// Check if we've seen this message recently
-	if lastSeen, exists := d.seenMessages[hash]; exists {
-		// If we've seen it within the last few seconds, it's a duplicate
-		if time.Since(lastSeen) < 2*time.Second {
-			return true
-		}
-	}
-
-	// Mark this message as seen
-	d.seenMessages[hash] = time.Now()
-	return false
-}
-
-// hashMessage creates a hash of the message for deduplication
-func (d *MessageDeduplicator) hashMessage(msg *types.ClineMessage) string {
-	// Create a hash based on message content, type, and timestamp
-	content := fmt.Sprintf("%s|%s|%s|%d",
-		string(msg.Type),
-		msg.Say,
-		msg.Ask,
-		msg.Timestamp)
-
-	// For partial messages, include the text content in the hash
-	if msg.Partial {
-		content += "|" + msg.Text
-	}
-
-	hash := md5.Sum([]byte(content))
-	return fmt.Sprintf("%x", hash)
-}
-
-// cleanup removes old entries from the seen messages map
-func (d *MessageDeduplicator) cleanup() {
-	for range d.cleanupTicker.C {
-		d.mu.Lock()
-		now := time.Now()
-
-		// Remove entries older than maxAge
-		for hash, timestamp := range d.seenMessages {
-			if now.Sub(timestamp) > d.maxAge {
-				delete(d.seenMessages, hash)
-			}
-		}
-
-		d.mu.Unlock()
-	}
-}
-
-// Stop stops the cleanup goroutine
-func (d *MessageDeduplicator) Stop() {
-	if d.cleanupTicker != nil {
-		d.cleanupTicker.Stop()
-	}
-}

cli/pkg/cli/display/markdown_renderer.go

@@ -1,139 +0,0 @@
-package display
-
-import (
-	"os"
-	"strconv"
-	"strings"
-
-	"fmt"
-
-	"github.com/charmbracelet/glamour"
-	"golang.org/x/term"
-)
-
-type MarkdownRenderer struct {
-	renderer *glamour.TermRenderer
-	width    int
-}
-
-// i went back and forth on whether or not to enable word wrap
-// setting line width to 0 enables the terminal to handle wrapping
-// setting it to a terminal width enables glamour's word wrap
-// the thing is, glamour's nice indentation looks really good, and
-// won't work without glamour's word wrap - if you use the terminal's
-// word wrap, the indentation looks weird so you have to turn it off
-// and everything will be right next to the left margin
-// but if you DO use glamours word wrap, it also means if you resize the terminal,
-// it will scuff everything. but given that this is the case for the input anyway, 
-// i figure we just make things as beautiful as possible 
-// and if you resize the terminal, you'll learn real quick.
-// anyway, you can set this to true or false to experiment
-const USETERMINALWORDWRAP = false
-
-
-// seems like a reliable way to check for terminals
-// for now i'm keeping everything as auto
-// eventually we can define a custom glamour style for ghostty / iterm
-// https://github.com/charmbracelet/glamour/blob/master/styles/README.md)
-func detectTerminalTheme() string {
-	switch os.Getenv("TERM_PROGRAM") {
-	case "iTerm.app", "Ghostty":
-		return "auto"
-	}
-	if os.Getenv("GHOSTTY_VERSION") != "" {
-		return "auto"
-	}
-	return "auto"
-}
-
-func glamourStyleJSON(terminalWrap bool) string {
-	const tmpl = `{
-		"document": {
-			"block_prefix": "\n",
-			"block_suffix": "\n",
-			"color": "252",
-			"margin": %s
-		},
-		"code_block": {
-			"margin": 0
-		}
-	}`
-	if terminalWrap {
-		return fmt.Sprintf(tmpl, "0")
-	}
-	return fmt.Sprintf(tmpl, "2")
-}
-
-
-
-
-func NewMarkdownRenderer() (*MarkdownRenderer, error) {
-	var wordWrap int
-	if USETERMINALWORDWRAP {
-		// terminal handles wrapping -> disable glamour wrap
-		wordWrap = 0
-	} else {
-		// glamour handles wrapping -> set to current width
-		wordWrap = terminalWidthOr(0)
-	}
-
-	r, err := glamour.NewTermRenderer(
-		glamour.WithStandardStyle(detectTerminalTheme()),              	 					 // Load full auto style first
-		glamour.WithStylesFromJSONBytes([]byte(glamourStyleJSON(USETERMINALWORDWRAP))),  	 // Then override just margins
-		glamour.WithWordWrap(wordWrap),                        
-		glamour.WithPreservedNewLines(),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return &MarkdownRenderer{
-		renderer: r,
-		width:    0, // Unlimited width
-	}, nil
-}
-
-// terminalWidthOr returns the terminal width or the provided fallback.
-// It first tries term.GetSize, then falls back to $COLUMNS if set.
-func terminalWidthOr(fallback int) int {
-	if w, _, err := term.GetSize(int(os.Stdout.Fd())); err == nil && w > 0 {
-		return w
-	}
-	if cols := os.Getenv("COLUMNS"); cols != "" {
-		if n, err := strconv.Atoi(cols); err == nil && n > 0 {
-			return n
-		}
-	}
-	return fallback
-}
-
-// NewMarkdownRendererWithWidth creates a markdown renderer with a specific width.
-// Useful for tables and other content that should fit within terminal bounds.
-func NewMarkdownRendererWithWidth(width int) (*MarkdownRenderer, error) {
-	r, err := glamour.NewTermRenderer(
-		glamour.WithStandardStyle(detectTerminalTheme()),
-		glamour.WithStylesFromJSONBytes([]byte(glamourStyleJSON(false))),
-		glamour.WithWordWrap(width),
-		glamour.WithPreservedNewLines(),
-	)
-	if err != nil {
-		return nil, err
-	}
-	return &MarkdownRenderer{renderer: r, width: width}, nil
-}
-
-
-// NewMarkdownRendererForTerminal creates a markdown renderer using the actual terminal width.
-// Falls back to 120 if terminal width cannot be determined.
-func NewMarkdownRendererForTerminal() (*MarkdownRenderer, error) {
-	width := terminalWidthOr(120)
-	return NewMarkdownRendererWithWidth(width)
-}
-
-func (mr *MarkdownRenderer) Render(markdown string) (string, error) {
-	rendered, err := mr.renderer.Render(markdown)
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimLeft(strings.TrimRight(rendered, "\n"), "\n"), nil
-}

cli/pkg/cli/display/renderer.go

@@ -1,225 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/types"
-	"github.com/cline/grpc-go/cline"
-)
-
-type Renderer struct {
-	typewriter   *TypewriterPrinter
-	mdRenderer   *MarkdownRenderer
-	outputFormat string
-}
-
-func NewRenderer(outputFormat string) *Renderer {
-	mdRenderer, err := NewMarkdownRenderer()
-	if err != nil {
-		mdRenderer = nil
-	}
-	
-	return &Renderer{
-		typewriter:   NewTypewriterPrinter(DefaultTypewriterConfig()),
-		mdRenderer:   mdRenderer,
-		outputFormat: outputFormat,
-	}
-}
-
-func (r *Renderer) RenderMessage(prefix, text string, newline bool) error {
-	if text == "" {
-		return nil
-	}
-
-	clean := r.sanitizeText(text)
-	if clean == "" {
-		return nil
-	}
-
-	if newline {
-		fmt.Printf("%s: %s\n", prefix, clean)
-	} else {
-		fmt.Printf("%s: %s", prefix, clean)
-	}
-	return nil
-}
-
-// formatNumber formats numbers with k/m abbreviations
-func formatNumber(n int) string {
-	if n >= 1000000 {
-		return fmt.Sprintf("%.1fm", float64(n)/1000000.0)
-	} else if n >= 1000 {
-		return fmt.Sprintf("%.1fk", float64(n)/1000.0)
-	}
-	return fmt.Sprintf("%d", n)
-}
-
-// formatUsageInfo formats token usage information (extracted from RenderAPI)
-func (r *Renderer) formatUsageInfo(tokensIn, tokensOut, cacheReads, cacheWrites int, cost float64) string {
-    parts := make([]string, 0, 4)
-
-    if tokensIn != 0 {
-        parts = append(parts, fmt.Sprintf("↑ %s", formatNumber(tokensIn)))
-    }
-    if tokensOut != 0 {
-        parts = append(parts, fmt.Sprintf("↓ %s", formatNumber(tokensOut)))
-    }
-    if cacheReads != 0 {
-        parts = append(parts, fmt.Sprintf("→ %s", formatNumber(cacheReads)))
-    }
-    if cacheWrites != 0 {
-        parts = append(parts, fmt.Sprintf("← %s", formatNumber(cacheWrites)))
-    }
-
-    if len(parts) == 0 {
-        return fmt.Sprintf("$%.4f", cost)
-    }
-
-    return fmt.Sprintf("%s $%.4f", strings.Join(parts, " "), cost)
-}
-
-
-func (r *Renderer) RenderAPI(status string, apiInfo *types.APIRequestInfo) error {
-	if apiInfo.Cost >= 0 {
-		usageInfo := r.formatUsageInfo(apiInfo.TokensIn, apiInfo.TokensOut, apiInfo.CacheReads, apiInfo.CacheWrites, apiInfo.Cost)
-		markdown := fmt.Sprintf("## API %s `%s`", status, usageInfo)
-		rendered := r.RenderMarkdown(markdown)
-		fmt.Printf(rendered)
-	} else {
-		// honestly i see no point in showing "### API processing request" here...
-		// markdown := fmt.Sprintf("## API %s", status)
-		// rendered := r.RenderMarkdown(markdown)
-		// fmt.Printf("\n%s\n", rendered)
-	}
-	return nil
-}
-
-func (r *Renderer) RenderRetry(attempt, maxAttempts, delaySec int) error {
-	message := fmt.Sprintf("Retrying failed attempt %d/%d", attempt, maxAttempts)
-	if delaySec > 0 {
-		message += fmt.Sprintf(" in %d seconds", delaySec)
-	}
-	message += "..."
-	r.typewriter.PrintMessageLine("API INFO", message)
-	return nil
-}
-
-func (r *Renderer) RenderTaskCancelled() error {
-	markdown := "## Task cancelled"
-	rendered := r.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-	return nil
-}
-
-// RenderTaskList displays task history with improved formatting
-func (r *Renderer) RenderTaskList(tasks []*cline.TaskItem) error {
-	const maxTasks = 20
-
-	startIndex := 0
-	if len(tasks) > maxTasks {
-		startIndex = len(tasks) - maxTasks
-	}
-
-	recentTasks := tasks[startIndex:]
-
-	r.typewriter.PrintfLn("=== Task History (showing last %d of %d total tasks) ===\n", len(recentTasks), len(tasks))
-
-	for i, task := range recentTasks {
-		r.typewriter.PrintfLn("Task ID: %s", task.Id)
-
-		description := task.Task
-		if len(description) > 1000 {
-			description = description[:1000] + "..."
-		}
-		r.typewriter.PrintfLn("Message: %s", description)
-
-		usageInfo := r.formatUsageInfo(int(task.TokensIn), int(task.TokensOut), int(task.CacheReads), int(task.CacheWrites), task.TotalCost)
-		r.typewriter.PrintfLn("Usage  : %s", usageInfo)
-
-		// Single space between tasks (except last)
-		if i < len(recentTasks)-1 {
-			r.typewriter.PrintfLn("")
-		}
-	}
-
-	return nil
-}
-
-func (r *Renderer) RenderDebug(format string, args ...interface{}) error {
-	if global.Config.Verbose {
-		message := fmt.Sprintf(format, args...)
-		r.typewriter.PrintMessageLine("[DEBUG]", message)
-	}
-	return nil
-}
-
-func (r *Renderer) ClearLine() {
-	fmt.Print("\r\033[K")
-}
-
-func (r *Renderer) MoveCursorUp(n int) {
-	fmt.Printf("\033[%dA", n)
-}
-
-func (r *Renderer) sanitizeText(text string) string {
-	text = strings.TrimSpace(text)
-
-	if text == "" {
-		return ""
-	}
-
-	// Remove control characters and escape sequences
-	var result strings.Builder
-	for _, r := range text {
-		// Keep printable characters, spaces, tabs, and newlines
-		if r >= 32 || r == '\t' || r == '\n' || r == '\r' {
-			result.WriteRune(r)
-		}
-		// Skip control characters (0-31 except tab, newline, carriage return)
-	}
-
-	return result.String()
-}
-
-func (r *Renderer) SetTypewriterEnabled(enabled bool) {
-	r.typewriter.SetEnabled(enabled)
-}
-
-func (r *Renderer) IsTypewriterEnabled() bool {
-	return r.typewriter.IsEnabled()
-}
-
-func (r *Renderer) SetTypewriterSpeed(multiplier float64) {
-	r.typewriter.SetSpeed(multiplier)
-}
-
-func (r *Renderer) GetTypewriter() *TypewriterPrinter {
-	return r.typewriter
-}
-
-func (r *Renderer) GetMdRenderer() *MarkdownRenderer {
-	return r.mdRenderer
-}
-
-// RenderMarkdown renders markdown text to terminal format with ANSI codes
-// Falls back to plaintext if markdown rendering is unavailable or fails
-// Respects output format - skips rendering in plain mode
-func (r *Renderer) RenderMarkdown(markdown string) string {
-	// Skip markdown rendering in plain mode
-	if r.outputFormat == "plain" {
-		return markdown
-	}
-	
-	if r.mdRenderer == nil {
-		return markdown
-	}
-	
-	rendered, err := r.mdRenderer.Render(markdown)
-	if err != nil {
-		return markdown
-	}
-	
-	return rendered
-}

cli/pkg/cli/display/segment_streamer.go

@@ -1,211 +0,0 @@
-package display
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-type StreamingSegment struct {
-	mu             sync.Mutex
-	sayType        string
-	prefix         string
-	buffer         strings.Builder
-	frozen         bool
-	mdRenderer     *MarkdownRenderer
-	toolRenderer   *ToolRenderer
-	shouldMarkdown bool
-	outputFormat   string
-	msg            *types.ClineMessage
-	toolParser     *ToolResultParser
-}
-
-func NewStreamingSegment(sayType, prefix string, mdRenderer *MarkdownRenderer, shouldMarkdown bool, msg *types.ClineMessage, outputFormat string) *StreamingSegment {
-	ss := &StreamingSegment{
-		sayType:        sayType,
-		prefix:         prefix,
-		mdRenderer:     mdRenderer,
-		toolRenderer:   NewToolRenderer(mdRenderer, outputFormat),
-		shouldMarkdown: shouldMarkdown,
-		outputFormat:   outputFormat,
-		msg:            msg,
-		toolParser:     NewToolResultParser(mdRenderer),
-	}
-	
-	// Render rich header immediately when creating segment (if in rich mode)
-	if shouldMarkdown && outputFormat != "plain" {
-		header := ss.generateRichHeader()
-		rendered, _ := mdRenderer.Render(header)
-		fmt.Println()
-		fmt.Print(rendered)
-	}
-	
-	return ss
-}
-
-func (ss *StreamingSegment) AppendText(text string) {
-	ss.mu.Lock()
-	defer ss.mu.Unlock()
-
-	if ss.frozen {
-		return
-	}
-
-	// Replace buffer with FULL text - msg.Text contains complete accumulated content
-	ss.buffer.Reset()
-	ss.buffer.WriteString(text)
-	
-	// No rendering during streaming - we'll render once on Freeze()
-}
-
-
-func (ss *StreamingSegment) Freeze() {
-	ss.mu.Lock()
-	defer ss.mu.Unlock()
-
-	if ss.frozen {
-		return
-	}
-
-	ss.frozen = true
-	currentBuffer := ss.buffer.String()
-	
-	// Render and print the final markdown
-	ss.renderFinal(currentBuffer)
-}
-
-func (ss *StreamingSegment) renderFinal(currentBuffer string) {
-	var bodyContent string
-
-	// Use ToolRenderer for all body rendering to centralize logic
-	if ss.sayType == "ask" {
-		// Handle ASK messages
-		if ss.msg.Ask == string(types.AskTypeTool) {
-			// Tool approval: use ToolRenderer for body
-			var tool types.ToolMessage
-			if err := json.Unmarshal([]byte(currentBuffer), &tool); err == nil {
-				// For approval requests in streaming, use the preview method
-				bodyContent = ss.toolRenderer.GenerateToolContentPreview(&tool)
-			}
-		} else if ss.msg.Ask == string(types.AskTypeFollowup) {
-			// Followup question: use ToolRenderer
-			bodyContent = ss.toolRenderer.GenerateAskFollowupBody(currentBuffer)
-		} else if ss.msg.Ask == string(types.AskTypePlanModeRespond) {
-			// Plan mode respond: use ToolRenderer
-			bodyContent = ss.toolRenderer.GeneratePlanModeRespondBody(currentBuffer)
-		} else if ss.msg.Ask == string(types.AskTypeCommand) {
-			// Command approval: no body needed - header shows command, output shown separately later
-			bodyContent = ""
-		} else {
-			// For other ask types, render as-is
-			bodyContent = currentBuffer
-		}
-	} else if ss.sayType == string(types.SayTypeTool) {
-		// Tool execution (SAY): use ToolRenderer for body
-		var tool types.ToolMessage
-		if err := json.Unmarshal([]byte(currentBuffer), &tool); err == nil {
-			bodyContent = ss.toolRenderer.GenerateToolContentBody(&tool)
-		}
-	} else if ss.sayType == string(types.SayTypeCommand) {
-		// Command output
-		bodyContent = "```shell\n" + currentBuffer + "\n```"
-		// Render markdown
-		if ss.shouldMarkdown && ss.outputFormat != "plain" {
-			rendered, err := ss.mdRenderer.Render(bodyContent)
-			if err == nil {
-				bodyContent = rendered
-			}
-		}
-	} else {
-		// For other types (reasoning, text, etc.), render markdown as-is
-		if ss.shouldMarkdown && ss.outputFormat != "plain" {
-			rendered, err := ss.mdRenderer.Render(currentBuffer)
-			if err == nil {
-				bodyContent = rendered
-			} else {
-				bodyContent = currentBuffer
-			}
-		} else {
-			bodyContent = currentBuffer
-		}
-	}
-
-	// Print the body content
-	if bodyContent != "" {
-		if !strings.HasSuffix(bodyContent, "\n") {
-			fmt.Print(bodyContent)
-			fmt.Println()
-		} else {
-			fmt.Print(bodyContent)
-		}
-	}
-}
-
-
-// generateRichHeader generates a contextual header for the segment
-func (ss *StreamingSegment) generateRichHeader() string {
-	switch ss.sayType {
-	case string(types.SayTypeReasoning):
-		return "### Cline is thinking\n"
-		
-	case string(types.SayTypeText):
-		return "### Cline responds\n"
-		
-	case string(types.SayTypeCompletionResult):
-		return "### Task completed\n"
-		
-	case string(types.SayTypeTool):
-		return ss.generateToolHeader()
-		
-	case "ask":
-		// Check the specific ask type
-		if ss.msg.Ask == string(types.AskTypePlanModeRespond) {
-			return ss.toolRenderer.GeneratePlanModeRespondHeader()
-		}
-
-		// For tool approvals, show proper tool header
-		if ss.msg.Ask == string(types.AskTypeTool) {
-			var tool types.ToolMessage
-			if err := json.Unmarshal([]byte(ss.msg.Text), &tool); err == nil {
-				// Use ToolRenderer for approval header with "wants to" verbs
-				return ss.toolRenderer.RenderToolApprovalHeader(&tool)
-			}
-		}
-
-		// For command approvals, show command header
-		if ss.msg.Ask == string(types.AskTypeCommand) {
-			command := strings.TrimSpace(ss.msg.Text)
-			if strings.HasSuffix(command, "REQ_APP") {
-				command = strings.TrimSuffix(command, "REQ_APP")
-				command = strings.TrimSpace(command)
-			}
-			return fmt.Sprintf("### Cline wants to run `%s`\n", command)
-		}
-
-		// For followup questions, show question header
-		if ss.msg.Ask == string(types.AskTypeFollowup) {
-			return ss.toolRenderer.GenerateAskFollowupHeader()
-		}
-
-		// For other ask types, show generic message
-		return fmt.Sprintf("### Cline is asking (%s)\n", ss.msg.Ask)
-		
-	default:
-		return fmt.Sprintf("### %s\n", ss.prefix)
-	}
-}
-
-// generateToolHeader generates a contextual header for tool operations
-func (ss *StreamingSegment) generateToolHeader() string {
-	// Parse tool JSON from message text
-	var tool types.ToolMessage
-	if err := json.Unmarshal([]byte(ss.msg.Text), &tool); err != nil {
-		return "### Tool operation\n"
-	}
-
-	// Use unified ToolRenderer for header
-	return ss.toolRenderer.RenderToolExecutionHeader(&tool)
-}

cli/pkg/cli/display/streaming.go

@@ -1,134 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// StreamingDisplay manages streaming message display with deduplication
-type StreamingDisplay struct {
-	mu            sync.RWMutex
-	state         *types.ConversationState
-	renderer      *Renderer
-	dedupe        *MessageDeduplicator
-	activeSegment *StreamingSegment
-	mdRenderer    *MarkdownRenderer
-}
-
-// NewStreamingDisplay creates a new streaming display manager
-func NewStreamingDisplay(state *types.ConversationState, renderer *Renderer) *StreamingDisplay {
-	mdRenderer, err := NewMarkdownRenderer()
-	if err != nil {
-		panic(fmt.Sprintf("Failed to initialize markdown renderer: %v", err))
-	}
-
-	return &StreamingDisplay{
-		state:      state,
-		renderer:   renderer,
-		dedupe:     NewMessageDeduplicator(),
-		mdRenderer: mdRenderer,
-	}
-}
-
-// HandlePartialMessage processes partial messages with streaming support
-func (s *StreamingDisplay) HandlePartialMessage(msg *types.ClineMessage) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// Check for deduplication
-	if s.dedupe.IsDuplicate(msg) {
-		return nil
-	}
-
-	// Segment-based header-only streaming
-	// Partial stream only shows headers immediately, state stream will handle content bodies
-	sayType := msg.Say
-	if msg.Type == types.MessageTypeAsk {
-		sayType = "ask"
-	}
-
-	// Detect segment boundary
-	if s.activeSegment != nil && s.activeSegment.sayType != sayType {
-		// Just cleanup, don't freeze (no body to print)
-		s.activeSegment = nil
-	}
-
-	// On first partial message for a new segment type, create segment (prints header)
-	if s.activeSegment == nil && msg.Partial {
-		shouldMd := s.shouldRenderMarkdown(sayType)
-		prefix := s.getPrefix(sayType)
-		// NewStreamingSegment prints the header immediately
-		s.activeSegment = NewStreamingSegment(sayType, prefix, s.mdRenderer, shouldMd, msg, s.renderer.outputFormat)
-		// Header printed, done - don't append text or freeze
-		return nil
-	}
-
-	// For subsequent partial messages, do nothing (header already shown)
-	if msg.Partial {
-		return nil
-	}
-
-	// When message is complete (partial=false), render the content body
-	if s.activeSegment != nil {
-		// Had an active segment from partial messages - freeze to render body
-		s.activeSegment.AppendText(msg.Text)
-		s.activeSegment.Freeze()
-		s.activeSegment = nil
-	} else if !msg.Partial {
-		// Message arrived complete without partial phase - create segment and render immediately
-		shouldMd := s.shouldRenderMarkdown(sayType)
-		prefix := s.getPrefix(sayType)
-		segment := NewStreamingSegment(sayType, prefix, s.mdRenderer, shouldMd, msg, s.renderer.outputFormat)
-		segment.AppendText(msg.Text)
-		segment.Freeze()
-	}
-
-	return nil
-}
-
-func (s *StreamingDisplay) shouldRenderMarkdown(sayType string) bool {
-	switch sayType {
-	case string(types.SayTypeReasoning), string(types.SayTypeText), string(types.SayTypeCompletionResult), string(types.SayTypeTool), "ask":
-		return true
-	default:
-		return false
-	}
-}
-
-func (s *StreamingDisplay) getPrefix(sayType string) string {
-	switch sayType {
-	case string(types.SayTypeReasoning):
-		return "THINKING"
-	case string(types.SayTypeText):
-		return "CLINE"
-	case string(types.SayTypeCompletionResult):
-		return "RESULT"
-	case "ask":
-		return "ASK"
-	case string(types.SayTypeCommand):
-		return "TERMINAL"
-	default:
-		return strings.ToUpper(sayType)
-	}
-}
-
-func (s *StreamingDisplay) FreezeActiveSegment() {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.activeSegment != nil {
-		s.activeSegment.Freeze()
-		s.activeSegment = nil
-	}
-}
-
-// Cleanup cleans up streaming display resources
-func (s *StreamingDisplay) Cleanup() {
-	s.FreezeActiveSegment()
-	if s.dedupe != nil {
-		s.dedupe.Stop()
-	}
-}

cli/pkg/cli/display/system_renderer.go

@@ -1,269 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/clerror"
-)
-
-// ErrorSeverity represents the severity level of an error
-type ErrorSeverity string
-
-const (
-	SeverityCritical ErrorSeverity = "critical"
-	SeverityWarning  ErrorSeverity = "warning"
-	SeverityInfo     ErrorSeverity = "info"
-)
-
-// SystemMessageRenderer handles rendering of system messages (errors, warnings, info)
-type SystemMessageRenderer struct {
-	renderer     *Renderer
-	mdRenderer   *MarkdownRenderer
-	outputFormat string
-}
-
-// NewSystemMessageRenderer creates a new system message renderer
-func NewSystemMessageRenderer(renderer *Renderer, mdRenderer *MarkdownRenderer, outputFormat string) *SystemMessageRenderer {
-	return &SystemMessageRenderer{
-		renderer:     renderer,
-		mdRenderer:   mdRenderer,
-		outputFormat: outputFormat,
-	}
-}
-
-// RenderError renders a beautiful error message with optional details
-func (sr *SystemMessageRenderer) RenderError(severity ErrorSeverity, title, body string, details map[string]string) error {
-	var colorMarkdown string
-
-	switch severity {
-	case SeverityCritical:
-		colorMarkdown = "**[ERROR]**"
-	case SeverityWarning:
-		colorMarkdown = "**[WARNING]**"
-	case SeverityInfo:
-		colorMarkdown = "**[INFO]**"
-	}
-
-	// Build the error message in markdown
-	var parts []string
-
-	// Header
-	header := fmt.Sprintf("### %s %s", colorMarkdown, title)
-	parts = append(parts, header)
-
-	// Body
-	if body != "" {
-		parts = append(parts, "", body)
-	}
-
-	// Details
-	if len(details) > 0 {
-		parts = append(parts, "", "**Details:**")
-		for key, value := range details {
-			parts = append(parts, fmt.Sprintf("- %s: `%s`", key, value))
-		}
-	}
-
-	markdown := strings.Join(parts, "\n")
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-
-	return nil
-}
-
-// RenderBalanceError renders a special balance/credits error with helpful info
-func (sr *SystemMessageRenderer) RenderBalanceError(err *clerror.ClineError) error {
-	var parts []string
-
-	// Header
-	parts = append(parts, "### **[ERROR]** Credit Limit Reached")
-	parts = append(parts, "")
-
-	// Message - prefer detail message from error.details, fallback to main message
-	message := err.Message
-	if detailMsg := err.GetDetailMessage(); detailMsg != "" {
-		message = detailMsg
-	}
-	parts = append(parts, message)
-	parts = append(parts, "")
-
-	// Account Balance section
-	parts = append(parts, "**Account Balance:**")
-
-	// Current balance
-	if balance := err.GetCurrentBalance(); balance != nil {
-		parts = append(parts, fmt.Sprintf("- Current Balance: **$%.2f**", *balance))
-	}
-
-	// Total spent
-	if spent := err.GetTotalSpent(); spent != nil {
-		parts = append(parts, fmt.Sprintf("- Total Spent: $%.2f", *spent))
-	}
-
-	// Promotions applied
-	if promos := err.GetTotalPromotions(); promos != nil {
-		parts = append(parts, fmt.Sprintf("- Promotions Applied: $%.2f", *promos))
-	}
-
-	parts = append(parts, "")
-
-	// Buy credits link
-	if url := err.GetBuyCreditsURL(); url != "" {
-		parts = append(parts, fmt.Sprintf("**→ Buy credits:** %s", url))
-	} else {
-		// Fallback - show both personal and org URLs
-		parts = append(parts, "**→ Buy credits:**")
-		parts = append(parts, "  - Personal: https://app.cline.bot/dashboard/account?tab=credits")
-		parts = append(parts, "  - Organization: https://app.cline.bot/dashboard/organization?tab=credits")
-	}
-
-	// Request ID (less prominent at the end)
-	if err.RequestID != "" {
-		parts = append(parts, "")
-		parts = append(parts, fmt.Sprintf("*Request ID: %s*", err.RequestID))
-	}
-
-	markdown := strings.Join(parts, "\n")
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-
-	return nil
-}
-
-// RenderAuthError renders an authentication error with helpful guidance
-func (sr *SystemMessageRenderer) RenderAuthError(err *clerror.ClineError) error {
-	var parts []string
-
-	// Header
-	parts = append(parts, "### **[ERROR]** Authentication Failed")
-	parts = append(parts, "")
-
-	// Message - prefer detail message if available
-	message := err.Message
-	if detailMsg := err.GetDetailMessage(); detailMsg != "" {
-		message = detailMsg
-	}
-	parts = append(parts, message)
-	parts = append(parts, "")
-
-	// Guidance
-	parts = append(parts, "**Next Steps:**")
-	parts = append(parts, "- Check your API key configuration")
-	parts = append(parts, "- Run `cline auth` to authenticate")
-	parts = append(parts, "- Verify your account status at https://app.cline.bot")
-
-	// Request ID
-	if err.RequestID != "" {
-		parts = append(parts, "")
-		parts = append(parts, fmt.Sprintf("*Request ID: `%s`*", err.RequestID))
-	}
-
-	markdown := strings.Join(parts, "\n")
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-
-	return nil
-}
-
-// RenderRateLimitError renders a rate limit error with request ID
-func (sr *SystemMessageRenderer) RenderRateLimitError(err *clerror.ClineError) error {
-	var parts []string
-
-	// Header
-	parts = append(parts, "### **[WARNING]** Rate Limit Reached")
-	parts = append(parts, "")
-
-	// Message - prefer detail message if available
-	message := err.Message
-	if detailMsg := err.GetDetailMessage(); detailMsg != "" {
-		message = detailMsg
-	}
-	parts = append(parts, message)
-	parts = append(parts, "")
-
-	// Guidance
-	parts = append(parts, "The API will automatically retry this request.")
-
-	// Request ID
-	if err.RequestID != "" {
-		parts = append(parts, "")
-		parts = append(parts, fmt.Sprintf("*Request ID: `%s`*", err.RequestID))
-	}
-
-	markdown := strings.Join(parts, "\n")
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-
-	return nil
-}
-
-// RenderAPIError renders a generic API error with all available details
-func (sr *SystemMessageRenderer) RenderAPIError(err *clerror.ClineError) error {
-	var parts []string
-
-	// Header
-	parts = append(parts, "### **[ERROR]** API Request Failed")
-	parts = append(parts, "")
-
-	// Message - prefer detail message if available
-	message := err.Message
-	if detailMsg := err.GetDetailMessage(); detailMsg != "" {
-		message = detailMsg
-	}
-	parts = append(parts, message)
-
-	// Details
-	var details []string
-	if err.RequestID != "" {
-		details = append(details, fmt.Sprintf("- Request ID: `%s`", err.RequestID))
-	}
-	if code := err.GetCodeString(); code != "" {
-		details = append(details, fmt.Sprintf("- Error Code: `%s`", code))
-	}
-	if err.Status > 0 {
-		details = append(details, fmt.Sprintf("- HTTP Status: `%d`", err.Status))
-	}
-	if err.ModelID != "" {
-		details = append(details, fmt.Sprintf("- Model: `%s`", err.ModelID))
-	}
-	if err.ProviderID != "" {
-		details = append(details, fmt.Sprintf("- Provider: `%s`", err.ProviderID))
-	}
-
-	if len(details) > 0 {
-		parts = append(parts, "")
-		parts = append(parts, "**Details:**")
-		parts = append(parts, strings.Join(details, "\n"))
-	}
-
-	markdown := strings.Join(parts, "\n")
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-
-	return nil
-}
-
-// RenderWarning renders a warning message
-func (sr *SystemMessageRenderer) RenderWarning(title, message string) error {
-	markdown := fmt.Sprintf("### **[WARNING]** %s\n\n%s", title, message)
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-	return nil
-}
-
-// RenderInfo renders an info message
-func (sr *SystemMessageRenderer) RenderInfo(title, message string) error {
-	markdown := fmt.Sprintf("### **[INFO]** %s\n\n%s", title, message)
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
-	return nil
-}
-
-// RenderCheckpoint renders a checkpoint creation message
-func (sr *SystemMessageRenderer) RenderCheckpoint(timestamp string, id int64) error {
-	markdown := fmt.Sprintf("## [%s] Checkpoint created `%d`", timestamp, id)
-	rendered := sr.renderer.RenderMarkdown(markdown)
-	fmt.Printf(rendered)
-	return nil
-}

cli/pkg/cli/display/tool_renderer.go

@@ -1,445 +0,0 @@
-package display
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// ToolRenderer provides unified rendering for tool and command messages
-type ToolRenderer struct {
-	mdRenderer   *MarkdownRenderer
-	outputFormat string
-}
-
-// NewToolRenderer creates a new tool renderer
-func NewToolRenderer(mdRenderer *MarkdownRenderer, outputFormat string) *ToolRenderer {
-	return &ToolRenderer{
-		mdRenderer:   mdRenderer,
-		outputFormat: outputFormat,
-	}
-}
-
-// RenderToolApprovalRequest renders a tool approval request ("Cline wants to...")
-func (tr *ToolRenderer) RenderToolApprovalRequest(tool *types.ToolMessage) string {
-	var output strings.Builder
-
-	// Generate header
-	header := tr.generateToolHeader(tool, "wants to")
-	rendered := tr.renderMarkdown(header)
-	output.WriteString(rendered)
-	output.WriteString("\n")
-
-	// Add content preview for relevant tools
-	contentPreview := tr.GenerateToolContentPreview(tool)
-	if contentPreview != "" {
-		output.WriteString("\n")
-		output.WriteString(contentPreview)
-	}
-
-	return output.String()
-}
-
-// RenderToolExecution renders a completed tool execution ("Cline is ...ing")
-func (tr *ToolRenderer) RenderToolExecution(tool *types.ToolMessage) string {
-	var output strings.Builder
-
-	// Generate header
-	header := tr.generateToolHeader(tool, "is")
-	rendered := tr.renderMarkdown(header)
-	output.WriteString("\n")
-	output.WriteString(rendered)
-	output.WriteString("\n")
-
-	// Add content body for relevant tools
-	contentBody := tr.GenerateToolContentBody(tool)
-	if contentBody != "" {
-		output.WriteString("\n")
-		output.WriteString(contentBody)
-		output.WriteString("\n")
-	}
-
-	return output.String()
-}
-
-// RenderToolExecutionHeader renders just the header for streaming (no body)
-func (tr *ToolRenderer) RenderToolExecutionHeader(tool *types.ToolMessage) string {
-	header := tr.generateToolHeader(tool, "is")
-	return header
-}
-
-// RenderToolApprovalHeader renders just the header for approval requests (no body)
-func (tr *ToolRenderer) RenderToolApprovalHeader(tool *types.ToolMessage) string {
-	header := tr.generateToolHeader(tool, "wants to")
-	return header
-}
-
-// generateToolHeader generates the markdown header for a tool message
-func (tr *ToolRenderer) generateToolHeader(tool *types.ToolMessage, verbTense string) string {
-	var verb string
-	var action string
-
-	switch tool.Tool {
-	case string(types.ToolTypeEditedExistingFile):
-		if verbTense == "wants to" {
-			action = "wants to edit"
-		} else {
-			action = "is editing"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeNewFileCreated):
-		if verbTense == "wants to" {
-			action = "wants to write"
-		} else {
-			action = "is writing"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeReadFile):
-		if verbTense == "wants to" {
-			action = "wants to read"
-		} else {
-			action = "is reading"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeListFilesTopLevel):
-		if verbTense == "wants to" {
-			action = "wants to list files in"
-		} else {
-			action = "is listing files in"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeListFilesRecursive):
-		if verbTense == "wants to" {
-			action = "wants to recursively list files in"
-		} else {
-			action = "is recursively listing files in"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeSearchFiles):
-		if tool.Regex != "" && tool.Path != "" {
-			if verbTense == "wants to" {
-				action = "wants to search for"
-			} else {
-				action = "is searching for"
-			}
-			return fmt.Sprintf("### Cline %s `%s` in `%s`", action, tool.Regex, tool.Path)
-		} else if tool.Regex != "" {
-			if verbTense == "wants to" {
-				action = "wants to search for"
-			} else {
-				action = "is searching for"
-			}
-			return fmt.Sprintf("### Cline %s `%s`", action, tool.Regex)
-		} else {
-			if verbTense == "wants to" {
-				return "### Cline wants to search files"
-			} else {
-				return "### Cline is searching files"
-			}
-		}
-
-	case string(types.ToolTypeWebFetch):
-		if verbTense == "wants to" {
-			action = "wants to fetch"
-		} else {
-			action = "is fetching"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeListCodeDefinitionNames):
-		if verbTense == "wants to" {
-			action = "wants to list code definitions in"
-		} else {
-			action = "is listing code definitions in"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
-	case string(types.ToolTypeSummarizeTask):
-		if verbTense == "wants to" {
-			return "### Cline wants to condense the conversation"
-		} else {
-			return "### Cline condensed the conversation"
-		}
-
-	default:
-		if verbTense == "wants to" {
-			verb = "wants to use"
-		} else {
-			verb = "is using"
-		}
-		return fmt.Sprintf("### Cline %s tool: %s", verb, tool.Tool)
-	}
-}
-
-// GenerateToolContentPreview generates content preview for approval requests
-func (tr *ToolRenderer) GenerateToolContentPreview(tool *types.ToolMessage) string {
-	if tool.Content == "" {
-		return ""
-	}
-
-	switch tool.Tool {
-	case string(types.ToolTypeEditedExistingFile):
-		// Show diff for edits
-		diffMarkdown := fmt.Sprintf("```diff\n%s\n```", tool.Content)
-		return tr.renderMarkdown(diffMarkdown)
-
-	case string(types.ToolTypeNewFileCreated):
-		// Show content preview for new files (truncated)
-		preview := strings.TrimSpace(tool.Content)
-		if len(preview) > 500 {
-			preview = preview[:500] + "..."
-		}
-		previewMd := fmt.Sprintf("```\n%s\n```", preview)
-		return tr.renderMarkdown(previewMd)
-
-	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch):
-		// No preview for read/fetch operations
-		return ""
-
-	default:
-		// For other tools, show truncated content if available
-		preview := strings.TrimSpace(tool.Content)
-		if len(preview) > 200 {
-			preview = preview[:200] + "..."
-		}
-		if preview != "" {
-			return fmt.Sprintf("Preview: %s", preview)
-		}
-		return ""
-	}
-}
-
-// GenerateToolContentBody generates full content for completed executions
-func (tr *ToolRenderer) GenerateToolContentBody(tool *types.ToolMessage) string {
-	if tool.Content == "" {
-		return ""
-	}
-
-	// Use enhanced tool result parser for supported tools
-	toolParser := NewToolResultParser(tr.mdRenderer)
-
-	switch tool.Tool {
-	case string(types.ToolTypeReadFile):
-		// readFile: show header only, no body
-		return ""
-
-	case string(types.ToolTypeListFilesTopLevel),
-		string(types.ToolTypeListFilesRecursive),
-		string(types.ToolTypeListCodeDefinitionNames),
-		string(types.ToolTypeSearchFiles),
-		string(types.ToolTypeWebFetch):
-		// Use parser for structured output
-		preview := toolParser.ParseToolResult(tool)
-		return tr.renderMarkdown(preview)
-
-	case string(types.ToolTypeEditedExistingFile):
-		// Show the diff
-		diffMarkdown := fmt.Sprintf("```diff\n%s\n```", tool.Content)
-		return tr.renderMarkdown(diffMarkdown)
-
-	case string(types.ToolTypeNewFileCreated):
-		// Show file content preview
-		preview := strings.TrimSpace(tool.Content)
-		if len(preview) > 1000 {
-			preview = preview[:1000] + "..."
-		}
-		contentMd := fmt.Sprintf("```\n%s\n```", preview)
-		return tr.renderMarkdown(contentMd)
-
-	default:
-		// For unknown tools, show content as-is
-		if len(tool.Content) > 500 {
-			return tool.Content[:500] + "..."
-		}
-		return tool.Content
-	}
-}
-
-// RenderCommandApprovalRequest renders a command approval request
-func (tr *ToolRenderer) RenderCommandApprovalRequest(command string, autoApprovalConflict bool) string {
-	var output strings.Builder
-
-	// Clean command
-	command = strings.TrimSpace(command)
-	if strings.HasSuffix(command, "REQ_APP") {
-		command = strings.TrimSuffix(command, "REQ_APP")
-		command = strings.TrimSpace(command)
-		autoApprovalConflict = true
-	}
-
-	// Generate header
-	header := fmt.Sprintf("### Cline wants to run `%s`", command)
-	rendered := tr.renderMarkdown(header)
-	output.WriteString(rendered)
-	output.WriteString("\n")
-
-	// Show command in code block
-	cmdBlock := fmt.Sprintf("```shell\n%s\n```", command)
-	cmdRendered := tr.renderMarkdown(cmdBlock)
-	output.WriteString("\n")
-	output.WriteString(cmdRendered)
-
-	// Add warning if needed
-	if autoApprovalConflict {
-		output.WriteString("\nWARNING: The model has determined this command requires explicit approval.\n")
-	}
-
-	return output.String()
-}
-
-// RenderCommandExecution renders a command execution announcement
-func (tr *ToolRenderer) RenderCommandExecution(command string) string {
-	command = strings.TrimSpace(command)
-	header := fmt.Sprintf("### Cline is running `%s`", command)
-	rendered := tr.renderMarkdown(header)
-	return "\n" + rendered + "\n"
-}
-
-// RenderCommandOutput renders command output
-func (tr *ToolRenderer) RenderCommandOutput(output string) string {
-	var result strings.Builder
-
-	header := "### Terminal output"
-	rendered := tr.renderMarkdown(header)
-	result.WriteString("\n")
-	result.WriteString(rendered)
-	result.WriteString("\n\n")
-
-	// Show output in code block
-	outputBlock := fmt.Sprintf("```\n%s\n```", strings.TrimSpace(output))
-	outputRendered := tr.renderMarkdown(outputBlock)
-	result.WriteString(outputRendered)
-	result.WriteString("\n")
-
-	return result.String()
-}
-
-// RenderUserResponse renders user approval/rejection feedback
-func (tr *ToolRenderer) RenderUserResponse(approved bool, feedback string) string {
-	var symbol, status string
-
-	if approved {
-		symbol = "✓"
-		status = "Approved"
-	} else {
-		symbol = "✗"
-		status = "Rejected"
-	}
-
-	if feedback != "" {
-		return fmt.Sprintf("%s %s with feedback: %s\n", symbol, status, feedback)
-	}
-	return fmt.Sprintf("%s %s\n", symbol, status)
-}
-
-// renderMarkdown renders markdown if not in plain mode
-func (tr *ToolRenderer) renderMarkdown(markdown string) string {
-	if tr.outputFormat == "plain" {
-		return markdown
-	}
-
-	if tr.mdRenderer == nil {
-		return markdown
-	}
-
-	rendered, err := tr.mdRenderer.Render(markdown)
-	if err != nil {
-		return markdown
-	}
-
-	return rendered
-}
-
-// GenerateAskFollowupHeader generates the header for followup questions
-func (tr *ToolRenderer) GenerateAskFollowupHeader() string {
-	return "### Cline has a question\n"
-}
-
-// GenerateAskFollowupBody generates the body content for followup questions
-func (tr *ToolRenderer) GenerateAskFollowupBody(messageText string) string {
-	var question string
-	var options []string
-
-	// Try to parse as JSON
-	var askData types.AskData
-	if err := json.Unmarshal([]byte(messageText), &askData); err == nil {
-		question = askData.Question
-		options = askData.Options
-	} else {
-		question = messageText
-	}
-
-	if question == "" {
-		return ""
-	}
-
-	// Build the body
-	var body strings.Builder
-
-	// Render the question
-	rendered := tr.renderMarkdown(question)
-	body.WriteString(rendered)
-
-	// Add options if available
-	if len(options) > 0 {
-		body.WriteString("\n\nOptions:\n")
-		for i, option := range options {
-			body.WriteString(fmt.Sprintf("%d. %s\n", i+1, option))
-		}
-	}
-
-	return body.String()
-}
-
-// GeneratePlanModeRespondHeader generates the header for plan mode responses
-func (tr *ToolRenderer) GeneratePlanModeRespondHeader() string {
-	return "### Cline has a plan\n"
-}
-
-// GeneratePlanModeRespondBody generates the body content for plan mode responses
-func (tr *ToolRenderer) GeneratePlanModeRespondBody(messageText string) string {
-	var response string
-	var options []string
-
-	// Try to parse as JSON
-	type PlanModeResponse struct {
-		Response string   `json:"response"`
-		Options  []string `json:"options,omitempty"`
-	}
-
-	var planData PlanModeResponse
-	if err := json.Unmarshal([]byte(messageText), &planData); err == nil {
-		response = planData.Response
-		options = planData.Options
-	} else {
-		response = messageText
-	}
-
-	if response == "" {
-		return ""
-	}
-
-	// Build the body
-	var body strings.Builder
-
-	// Render the response
-	rendered := tr.renderMarkdown(response)
-	body.WriteString(rendered)
-
-	// Add options if available
-	if len(options) > 0 {
-		body.WriteString("\n\nOptions:\n")
-		for i, option := range options {
-			body.WriteString(fmt.Sprintf("%d. %s\n", i+1, option))
-		}
-	}
-
-	return body.String()
-}

cli/pkg/cli/display/tool_result_parser.go

@@ -1,371 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-
-	"github.com/cline/cli/pkg/cli/types"
-)
-
-// ToolResultParser handles parsing and formatting tool results for display
-type ToolResultParser struct {
-	maxPreviewLines int
-	maxPreviewChars int
-	mdRenderer      *MarkdownRenderer
-}
-
-// NewToolResultParser creates a new tool result parser
-func NewToolResultParser(mdRenderer *MarkdownRenderer) *ToolResultParser {
-	return &ToolResultParser{
-		maxPreviewLines: 15,
-		maxPreviewChars: 500,
-		mdRenderer:      mdRenderer,
-	}
-}
-
-// ParseReadFile formats readFile tool results with smart preview
-func (p *ToolResultParser) ParseReadFile(content, path string) string {
-	lines := strings.Split(content, "\n")
-	totalLines := len(lines)
-
-	// Get file extension for syntax highlighting
-	ext := filepath.Ext(path)
-	lang := p.detectLanguage(ext)
-
-	var preview strings.Builder
-
-	// Show header with line count
-	preview.WriteString(fmt.Sprintf("*%d lines*\n\n", totalLines))
-
-	// Show preview of content
-	previewLines := p.maxPreviewLines
-	if totalLines < previewLines {
-		previewLines = totalLines
-	}
-
-	preview.WriteString(fmt.Sprintf("```%s\n", lang))
-	for i := 0; i < previewLines; i++ {
-		preview.WriteString(lines[i])
-		preview.WriteString("\n")
-	}
-
-	if totalLines > previewLines {
-		preview.WriteString("...\n")
-	}
-	preview.WriteString("```\n")
-
-	if totalLines > previewLines {
-		preview.WriteString(fmt.Sprintf("\n*[Content truncated - showing %d of %d lines]*", previewLines, totalLines))
-	}
-
-	return preview.String()
-}
-
-// ParseListFiles formats listFiles tool results with directory tree
-func (p *ToolResultParser) ParseListFiles(content, path string) string {
-	if content == "" || content == "No files found." {
-		return "*No files found*"
-	}
-
-	lines := strings.Split(strings.TrimSpace(content), "\n")
-	
-	// Check for truncation message
-	var truncationMsg string
-	lastLine := lines[len(lines)-1]
-	if strings.Contains(lastLine, "File list truncated") {
-		truncationMsg = lastLine
-		lines = lines[:len(lines)-1]
-	}
-
-	totalFiles := len(lines)
-	
-	var result strings.Builder
-	result.WriteString(fmt.Sprintf("*%d %s*\n\n", totalFiles, p.pluralize(totalFiles, "file", "files")))
-
-	// Show up to 20 files in tree format
-	maxShow := 20
-	if totalFiles < maxShow {
-		maxShow = totalFiles
-	}
-
-	result.WriteString("```\n")
-	for i := 0; i < maxShow; i++ {
-		line := lines[i]
-		// Add tree characters for better visualization
-		if strings.HasPrefix(line, "🔒 ") {
-			result.WriteString("├── 🔒 ")
-			result.WriteString(strings.TrimPrefix(line, "🔒 "))
-		} else {
-			result.WriteString("├── ")
-			result.WriteString(line)
-		}
-		result.WriteString("\n")
-	}
-
-	if totalFiles > maxShow {
-		result.WriteString("└── ...\n")
-	}
-	result.WriteString("```\n")
-
-	if totalFiles > maxShow {
-		result.WriteString(fmt.Sprintf("\n*[Showing %d of %d files]*", maxShow, totalFiles))
-	}
-
-	if truncationMsg != "" {
-		result.WriteString(fmt.Sprintf("\n\n*%s*", truncationMsg))
-	}
-
-	return result.String()
-}
-
-// ParseSearchFiles formats searchFiles tool results with context
-func (p *ToolResultParser) ParseSearchFiles(content string) string {
-	if content == "" || content == "Found 0 results." {
-		return "*No results found*"
-	}
-
-	lines := strings.Split(content, "\n")
-	if len(lines) == 0 {
-		return "*No results found*"
-	}
-
-	// Extract result count from first line
-	firstLine := lines[0]
-	
-	var result strings.Builder
-	result.WriteString(fmt.Sprintf("*%s*\n\n", firstLine))
-
-	// Parse and group results by file
-	var currentFile string
-	var fileResults []string
-	filesShown := 0
-	maxFiles := 5
-	matchesShown := 0
-	maxMatches := 15
-
-	for i := 1; i < len(lines) && filesShown < maxFiles && matchesShown < maxMatches; i++ {
-		line := lines[i]
-		
-		if line == "" {
-			continue
-		}
-
-		// Check if this is a file path (doesn't start with whitespace or line number)
-		if !strings.HasPrefix(line, " ") && !strings.HasPrefix(line, "\t") && strings.Contains(line, ":") {
-			// Save previous file results
-			if currentFile != "" && len(fileResults) > 0 {
-				result.WriteString(p.formatFileMatches(currentFile, fileResults))
-				filesShown++
-			}
-			
-			currentFile = line
-			fileResults = []string{}
-		} else if currentFile != "" {
-			// This is a match line
-			fileResults = append(fileResults, strings.TrimSpace(line))
-			matchesShown++
-		}
-	}
-
-	// Add last file's results
-	if currentFile != "" && len(fileResults) > 0 && filesShown < maxFiles {
-		result.WriteString(p.formatFileMatches(currentFile, fileResults))
-		filesShown++
-	}
-
-	// Add truncation notice
-	totalMatches := strings.Count(content, "\n") - 1 // Rough estimate
-	if matchesShown < totalMatches {
-		result.WriteString(fmt.Sprintf("\n*[Showing %d results - see full output for all matches]*", matchesShown))
-	}
-
-	return result.String()
-}
-
-// formatFileMatches formats matches for a single file
-func (p *ToolResultParser) formatFileMatches(file string, matches []string) string {
-	var result strings.Builder
-	
-	// Parse file path and extension for syntax highlighting
-	ext := filepath.Ext(file)
-	lang := p.detectLanguage(ext)
-	
-	result.WriteString(fmt.Sprintf("**%s** (%d %s)\n", file, len(matches), p.pluralize(len(matches), "match", "matches")))
-	result.WriteString(fmt.Sprintf("```%s\n", lang))
-	
-	maxMatches := 5
-	for i, match := range matches {
-		if i >= maxMatches {
-			result.WriteString("...\n")
-			break
-		}
-		result.WriteString(match)
-		result.WriteString("\n")
-	}
-	
-	result.WriteString("```\n\n")
-	
-	return result.String()
-}
-
-// ParseCodeDefinitions formats listCodeDefinitionNames tool results
-func (p *ToolResultParser) ParseCodeDefinitions(content string) string {
-	if content == "" || content == "No source code definitions found." {
-		return "*No code definitions found*"
-	}
-
-	// Return the full content as-is
-	return content
-}
-
-// ParseWebFetch formats webFetch tool results with content preview
-func (p *ToolResultParser) ParseWebFetch(content, url string) string {
-	if content == "" {
-		return fmt.Sprintf("*Fetched content from %s (empty response)*", url)
-	}
-
-	lines := strings.Split(content, "\n")
-	
-	var result strings.Builder
-	
-	// Try to extract title
-	var title string
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "#") && !strings.HasPrefix(trimmed, "##") {
-			title = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
-			break
-		}
-	}
-
-	if title != "" {
-		result.WriteString(fmt.Sprintf("**Title:** %s\n\n", title))
-	}
-
-	// Show preview of content
-	result.WriteString("**Preview:**\n")
-	
-	charCount := 0
-	maxChars := 500
-	previewLines := []string{}
-	
-	for _, line := range lines {
-		// Skip markdown headers
-		if strings.HasPrefix(strings.TrimSpace(line), "#") {
-			continue
-		}
-		
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" {
-			continue
-		}
-		
-		if charCount+len(trimmed) > maxChars {
-			break
-		}
-		
-		previewLines = append(previewLines, trimmed)
-		charCount += len(trimmed)
-	}
-
-	result.WriteString(strings.Join(previewLines, " "))
-	result.WriteString("...\n\n")
-
-	// Extract sections
-	sections := []string{}
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "##") {
-			section := strings.TrimSpace(strings.TrimPrefix(trimmed, "##"))
-			sections = append(sections, section)
-			if len(sections) >= 5 {
-				break
-			}
-		}
-	}
-
-	if len(sections) > 0 {
-		result.WriteString("**Sections Found:**\n")
-		for _, section := range sections {
-			result.WriteString(fmt.Sprintf("- %s\n", section))
-		}
-		result.WriteString("\n")
-	}
-
-	// Word count estimate
-	wordCount := len(strings.Fields(content))
-	result.WriteString(fmt.Sprintf("*[Full content: ~%s]*", p.formatWordCount(wordCount)))
-
-	return result.String()
-}
-
-// detectLanguage returns syntax highlighting language based on file extension
-func (p *ToolResultParser) detectLanguage(ext string) string {
-	langMap := map[string]string{
-		".ts":   "typescript",
-		".tsx":  "tsx",
-		".js":   "javascript",
-		".jsx":  "jsx",
-		".go":   "go",
-		".py":   "python",
-		".rb":   "ruby",
-		".java": "java",
-		".c":    "c",
-		".cpp":  "cpp",
-		".cs":   "csharp",
-		".php":  "php",
-		".sh":   "bash",
-		".bash": "bash",
-		".zsh":  "bash",
-		".json": "json",
-		".yaml": "yaml",
-		".yml":  "yaml",
-		".xml":  "xml",
-		".html": "html",
-		".css":  "css",
-		".scss": "scss",
-		".md":   "markdown",
-		".sql":  "sql",
-		".rs":   "rust",
-	}
-
-	if lang, ok := langMap[ext]; ok {
-		return lang
-	}
-	return ""
-}
-
-// pluralize returns the correct plural form
-func (p *ToolResultParser) pluralize(count int, singular, plural string) string {
-	if count == 1 {
-		return singular
-	}
-	return plural
-}
-
-// formatWordCount formats word count with appropriate unit
-func (p *ToolResultParser) formatWordCount(count int) string {
-	if count < 1000 {
-		return fmt.Sprintf("%d words", count)
-	}
-	return fmt.Sprintf("%.1fk words", float64(count)/1000.0)
-}
-
-// ParseToolResult is the main entry point for parsing tool results
-func (p *ToolResultParser) ParseToolResult(tool *types.ToolMessage) string {
-	switch tool.Tool {
-	case "readFile":
-		return p.ParseReadFile(tool.Content, tool.Path)
-	case "listFilesTopLevel", "listFilesRecursive":
-		return p.ParseListFiles(tool.Content, tool.Path)
-	case "searchFiles":
-		return p.ParseSearchFiles(tool.Content)
-	case "listCodeDefinitionNames":
-		return p.ParseCodeDefinitions(tool.Content)
-	case "webFetch":
-		return p.ParseWebFetch(tool.Content, tool.Path)
-	default:
-		return tool.Content
-	}
-}

cli/pkg/cli/display/typewriter.go

@@ -1,210 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"os"
-	"time"
-)
-
-// TypewriterConfig holds configuration for the typewriter effect
-type TypewriterConfig struct {
-	BaseDelay    time.Duration // Base delay between characters
-	FastDelay    time.Duration // Faster delay for common characters
-	SlowDelay    time.Duration // Slower delay for punctuation
-	PauseDelay   time.Duration // Pause after sentences
-	Enabled      bool          // Whether typewriter effect is enabled
-	RandomFactor float64       // Randomness factor (0.0 to 1.0)
-}
-
-// DefaultTypewriterConfig returns the default typewriter configuration
-func DefaultTypewriterConfig() *TypewriterConfig {
-	return &TypewriterConfig{
-		BaseDelay:    15 * time.Millisecond,
-		FastDelay:    8 * time.Millisecond,
-		SlowDelay:    25 * time.Millisecond,
-		PauseDelay:   150 * time.Millisecond,
-		Enabled:      false,
-		RandomFactor: 0.3,
-	}
-}
-
-// TypewriterPrinter handles typewriter-style output
-type TypewriterPrinter struct {
-	config *TypewriterConfig
-}
-
-// NewTypewriterPrinter creates a new typewriter printer
-func NewTypewriterPrinter(config *TypewriterConfig) *TypewriterPrinter {
-	if config == nil {
-		config = DefaultTypewriterConfig()
-	}
-	return &TypewriterPrinter{
-		config: config,
-	}
-}
-
-// Print prints text with typewriter effect
-func (tp *TypewriterPrinter) Print(text string) {
-	if !tp.config.Enabled {
-		fmt.Print(text)
-		return
-	}
-
-	tp.typewriterPrint(text)
-}
-
-// Printf prints formatted text with typewriter effect
-func (tp *TypewriterPrinter) Printf(format string, args ...interface{}) {
-	text := fmt.Sprintf(format, args...)
-	tp.Print(text)
-}
-
-// Println prints text with typewriter effect and adds a newline
-func (tp *TypewriterPrinter) Println(text string) {
-	tp.Print(text + "\n")
-}
-
-// PrintfLn prints formatted text with typewriter effect and adds a newline
-func (tp *TypewriterPrinter) PrintfLn(format string, args ...interface{}) {
-	text := fmt.Sprintf(format, args...)
-	tp.Println(text)
-}
-
-// PrintInstant prints text immediately without typewriter effect
-func (tp *TypewriterPrinter) PrintInstant(text string) {
-	fmt.Print(text)
-}
-
-// PrintfInstant prints formatted text immediately without typewriter effect
-func (tp *TypewriterPrinter) PrintfInstant(format string, args ...interface{}) {
-	fmt.Printf(format, args...)
-}
-
-// typewriterPrint displays text with a typewriter animation effect
-func (tp *TypewriterPrinter) typewriterPrint(text string) {
-	// Convert string to runes to handle Unicode properly
-	runes := []rune(text)
-
-	for i, r := range runes {
-		// Print the character
-		fmt.Print(string(r))
-		os.Stdout.Sync() // Force immediate output
-
-		// Don't add delay after the last character
-		if i == len(runes)-1 {
-			break
-		}
-
-		// Determine delay based on character type
-		delay := tp.getDelayForCharacter(r, i)
-
-		// Sleep for the calculated delay
-		time.Sleep(delay)
-	}
-}
-
-// getDelayForCharacter returns the appropriate delay for a character
-func (tp *TypewriterPrinter) getDelayForCharacter(r rune, position int) time.Duration {
-	var baseDelay time.Duration
-
-	switch {
-	case r == '.' || r == '!' || r == '?':
-		// Longer pause after sentence endings
-		baseDelay = tp.config.PauseDelay
-	case r == ',' || r == ';' || r == ':':
-		// Medium pause after punctuation
-		baseDelay = tp.config.SlowDelay
-	case r == ' ':
-		// Slightly faster for spaces
-		baseDelay = tp.config.FastDelay
-	case r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z':
-		// Fast for common letters
-		baseDelay = tp.config.FastDelay
-	case r == '\n':
-		// No delay for newlines
-		return 0
-	default:
-		// Base delay for other characters
-		baseDelay = tp.config.BaseDelay
-	}
-
-	// Add randomness to make it feel more natural
-	if tp.config.RandomFactor > 0 {
-		// Simple pseudo-random based on position to ensure consistency
-		randomFactor := 0.7 + (tp.config.RandomFactor * float64(position%7) / 6.0)
-		baseDelay = time.Duration(float64(baseDelay) * randomFactor)
-	}
-
-	return baseDelay
-}
-
-// SetEnabled enables or disables the typewriter effect
-func (tp *TypewriterPrinter) SetEnabled(enabled bool) {
-	tp.config.Enabled = enabled
-}
-
-// IsEnabled returns whether the typewriter effect is enabled
-func (tp *TypewriterPrinter) IsEnabled() bool {
-	return tp.config.Enabled
-}
-
-// SetSpeed adjusts the typewriter speed (multiplier: 0.1 = very slow, 1.0 = normal, 2.0 = fast)
-func (tp *TypewriterPrinter) SetSpeed(multiplier float64) {
-	if multiplier <= 0 {
-		multiplier = 1.0
-	}
-
-	tp.config.BaseDelay = time.Duration(float64(15*time.Millisecond) / multiplier)
-	tp.config.FastDelay = time.Duration(float64(8*time.Millisecond) / multiplier)
-	tp.config.SlowDelay = time.Duration(float64(25*time.Millisecond) / multiplier)
-	tp.config.PauseDelay = time.Duration(float64(150*time.Millisecond) / multiplier)
-}
-
-func (tp *TypewriterPrinter) PrintMessageLine(prefix, text string) {
-	tp.PrintfInstant("%s: ", prefix)
-	tp.Println(text)
-}
-
-// Global typewriter printer instance
-var globalTypewriter = NewTypewriterPrinter(DefaultTypewriterConfig())
-
-// Global convenience functions that use the global typewriter instance
-
-// TypewriterPrint prints text with typewriter effect using the global instance
-func TypewriterPrint(text string) {
-	globalTypewriter.Print(text)
-}
-
-// TypewriterPrintf prints formatted text with typewriter effect using the global instance
-func TypewriterPrintf(format string, args ...interface{}) {
-	globalTypewriter.Printf(format, args...)
-}
-
-// TypewriterPrintln prints text with typewriter effect and newline using the global instance
-func TypewriterPrintln(text string) {
-	globalTypewriter.Println(text)
-}
-
-// TypewriterPrintfLn prints formatted text with typewriter effect and newline using the global instance
-func TypewriterPrintfLn(format string, args ...interface{}) {
-	globalTypewriter.PrintfLn(format, args...)
-}
-
-func TypewriterPrintMessageLine(prefix, text string) {
-	globalTypewriter.PrintMessageLine(prefix, text)
-}
-
-// SetGlobalTypewriterEnabled enables or disables the global typewriter effect
-func SetGlobalTypewriterEnabled(enabled bool) {
-	globalTypewriter.SetEnabled(enabled)
-}
-
-// SetGlobalTypewriterSpeed sets the speed of the global typewriter effect
-func SetGlobalTypewriterSpeed(multiplier float64) {
-	globalTypewriter.SetSpeed(multiplier)
-}
-
-// GetGlobalTypewriter returns the global typewriter instance
-func GetGlobalTypewriter() *TypewriterPrinter {
-	return globalTypewriter
-}

cli/pkg/cli/global/cline-clients.go

@@ -1,435 +0,0 @@
-package global
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"syscall"
-	"time"
-
-	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/cline"
-)
-
-// ClineClients manages Cline instances using the new registry system
-type ClineClients struct {
-	registry *ClientRegistry
-}
-
-// NewClineClients creates a new ClineClients instance
-func NewClineClients(configPath string) *ClineClients {
-	registry := NewClientRegistry(configPath)
-	return &ClineClients{
-		registry: registry,
-	}
-}
-
-// Initialize performs cleanup of stale instances
-func (c *ClineClients) Initialize(ctx context.Context) error {
-	// Clean up stale entries (direct SQLite operations)
-	_ = c.registry.CleanupStaleInstances(ctx)
-
-	return nil
-}
-
-// StartNewInstance starts a new Cline instance and waits for cline-core to self-register
-func (c *ClineClients) StartNewInstance(ctx context.Context) (*common.CoreInstanceInfo, error) {
-	// Find available ports
-	corePort, hostPort, err := common.FindAvailablePortPair()
-	if err != nil {
-		return nil, fmt.Errorf("failed to find available ports: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Starting new Cline instance on ports %d (core) and %d (host bridge)\n", corePort, hostPort)
-	}
-
-	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, corePort)
-	if err != nil {
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	// Start cline-core (it will register itself in SQLite locks database)
-	coreCmd, err := startClineCore(corePort, hostPort)
-	if err != nil {
-		// Clean up host process if core fails to start
-		if hostCmd != nil && hostCmd.Process != nil {
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	fullAddress := fmt.Sprintf("localhost:%d", corePort)
-	if Config.Verbose {
-		fmt.Println("Waiting for services to start and self-register in SQLite...")
-	}
-
-	// Use RetryOperation to wait for instance to be ready
-	var instance *common.CoreInstanceInfo
-	err = common.RetryOperation(12, 5*time.Second, func() error {
-		// Check if instance registered itself in SQLite
-		foundInstance, err := c.registry.GetInstance(fullAddress)
-		if err != nil || foundInstance == nil {
-			return fmt.Errorf("instance not found in registry: %v", err)
-		}
-
-		// Verify instance is healthy
-		if !common.IsInstanceHealthy(ctx, fullAddress) {
-			return fmt.Errorf("instance is registered but not healthy")
-		}
-
-		// Success - store the instance for return
-		instance = foundInstance
-		return nil
-	})
-
-	if err != nil {
-		// Clean up both processes on failure
-		if coreCmd != nil && coreCmd.Process != nil {
-			fmt.Printf("Cleaning up core process (PID: %d)\n", coreCmd.Process.Pid)
-			coreCmd.Process.Kill()
-		}
-		if hostCmd != nil && hostCmd.Process != nil {
-			fmt.Printf("Cleaning up host process (PID: %d)\n", hostCmd.Process.Pid)
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start instance: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Println("Services started and registered successfully!")
-		fmt.Printf("  Address: %s\n", instance.Address)
-		fmt.Printf("  Core Port: %d\n", instance.CorePort())
-		fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
-		fmt.Printf("  Process PID: %d\n", coreCmd.Process.Pid)
-	}
-
-	// If this is the first instance, set it as default
-	instances := c.registry.ListInstances()
-	if err := c.registry.EnsureDefaultInstance(instances); err != nil {
-		if Config.Verbose {
-			fmt.Printf("Warning: Failed to set default instance: %v\n", err)
-		}
-	}
-
-	return instance, nil
-}
-
-// StartNewInstanceAtPort starts a new Cline instance at the specified port and waits for self-registration
-func (c *ClineClients) StartNewInstanceAtPort(ctx context.Context, corePort int) (*common.CoreInstanceInfo, error) {
-	// Find available host port (core port + 1000)
-	hostPort := corePort + 1000
-	coreAddress := fmt.Sprintf("localhost:%d", corePort)
-
-	// Check if the specified core port is available
-	if common.IsInstanceHealthy(ctx, coreAddress) {
-		return nil, fmt.Errorf("port %d is already in use by another Cline instance", corePort)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Starting new Cline instance on ports %d (core) and %d (host bridge)\n", corePort, hostPort)
-	}
-
-	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, corePort)
-	if err != nil {
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	// Start cline-core (it will register itself in SQLite locks database)
-	coreCmd, err := startClineCore(corePort, hostPort)
-	if err != nil {
-		// Clean up host process if core fails to start
-		if hostCmd != nil && hostCmd.Process != nil {
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	fullAddress := fmt.Sprintf("localhost:%d", corePort)
-	if Config.Verbose {
-		fmt.Println("Waiting for services to start and self-register in SQLite...")
-	}
-
-	// Use RetryOperation to wait for instance to be ready
-	var instance *common.CoreInstanceInfo
-	err = common.RetryOperation(12, 5*time.Second, func() error {
-		// Check if instance registered itself in SQLite
-		foundInstance, err := c.registry.GetInstance(fullAddress)
-		if err != nil || foundInstance == nil {
-			return fmt.Errorf("instance not found in registry: %v", err)
-		}
-
-		// Verify instance is healthy
-		if !common.IsInstanceHealthy(ctx, fullAddress) {
-			return fmt.Errorf("instance is registered but not healthy")
-		}
-
-		// Success - store the instance for return
-		instance = foundInstance
-		return nil
-	})
-
-	if err != nil {
-		// Clean up both processes on failure
-		if coreCmd != nil && coreCmd.Process != nil {
-			fmt.Printf("Cleaning up core process (PID: %d)\n", coreCmd.Process.Pid)
-			coreCmd.Process.Kill()
-		}
-		if hostCmd != nil && hostCmd.Process != nil {
-			fmt.Printf("Cleaning up host process (PID: %d)\n", hostCmd.Process.Pid)
-			hostCmd.Process.Kill()
-		}
-		return nil, fmt.Errorf("failed to start instance at port %d: %w", corePort, err)
-	}
-
-	if Config.Verbose {
-		fmt.Println("Services started and registered successfully!")
-		fmt.Printf("  Address: %s\n", instance.Address)
-		fmt.Printf("  Core Port: %d\n", instance.CorePort())
-		fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
-		fmt.Printf("  Process PID: %d\n", coreCmd.Process.Pid)
-	}
-
-	// If this is the first instance, set it as default
-	instances := c.registry.ListInstances()
-	if err := c.registry.EnsureDefaultInstance(instances); err != nil {
-		if Config.Verbose {
-			fmt.Printf("Warning: Failed to set default instance: %v\n", err)
-		}
-	}
-
-	return instance, nil
-}
-
-// GetRegistry returns the client registry
-func (c *ClineClients) GetRegistry() *ClientRegistry {
-	return c.registry
-}
-
-// EnsureInstanceAtAddress ensures an instance exists at the given address, starting one if needed
-func (c *ClineClients) EnsureInstanceAtAddress(ctx context.Context, address string) error {
-	// Expect host:port everywhere
-	normalized := address
-	if normalized == "" {
-		normalized = fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT)
-	}
-
-	// Check if instance already exists at this address
-	if c.registry.HasInstanceAtAddress(normalized) {
-		return nil
-	}
-
-	// Parse host:port
-	host, port, err := common.ParseHostPort(normalized)
-	if err != nil {
-		return fmt.Errorf("invalid address format %s", address)
-	}
-
-	// Use IPv6-compatible localhost detection
-	if common.IsLocalAddress(host) {
-		_, err := c.StartNewInstanceAtPort(ctx, port)
-		if err != nil {
-			return fmt.Errorf("failed to start new instance at %s: %w", normalized, err)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("cannot start remote instance at %s", normalized)
-}
-
-func startClineHost(hostPort, corePort int) (*exec.Cmd, error) {
-	if Config.Verbose {
-		fmt.Printf("Starting cline-host on port %d\n", hostPort)
-	}
-
-	// Get the directory where the cline binary is located
-	execPath, err := os.Executable()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get executable path: %w", err)
-	}
-	binDir := path.Dir(execPath)
-	clineHostPath := path.Join(binDir, "cline-host")
-
-	// Start the cline-host process
-	cmd := exec.Command(clineHostPath,
-		"--verbose",
-		"--port", fmt.Sprintf("%d", hostPort))
-
-	// Create logs directory in ~/.cline/logs
-	logsDir := path.Join(Config.ConfigPath, "logs")
-	if err := os.MkdirAll(logsDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	// Create timestamped log file
-	timestamp := time.Now().Format("2006-01-02-15-04-05")
-	logFileName := fmt.Sprintf("cline-host-%s-localhost-%d.log", timestamp, hostPort)
-	logFilePath := path.Join(logsDir, logFileName)
-	logFile, err := os.Create(logFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create log file: %w", err)
-	}
-
-	// Redirect stdout and stderr to log file
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	// Put the child process in a new process group so Ctrl+C doesn't kill it
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setpgid: true,
-	}
-
-	if err := cmd.Start(); err != nil {
-		logFile.Close()
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Started cline-host (PID: %d)\n", cmd.Process.Pid)
-		fmt.Printf("Logging cline-host output to: %s\n", logFilePath)
-	}
-	return cmd, nil
-}
-
-// KillInstanceByAddress kills a Cline instance by its address
-func KillInstanceByAddress(ctx context.Context, registry *ClientRegistry, address string) error {
-	// Check if the instance exists in the registry
-	_, err := registry.GetInstance(address)
-	if err != nil {
-		return fmt.Errorf("instance %s not found in registry", address)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Killing instance: %s\n", address)
-	}
-
-	// Get gRPC client and process info
-	client, err := registry.GetClient(ctx, address)
-	if err != nil {
-		return fmt.Errorf("failed to connect to instance %s: %w", address, err)
-	}
-
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get process info for instance %s: %w", address, err)
-	}
-
-	pid := int(processInfo.ProcessId)
-	if Config.Verbose {
-		fmt.Printf("Terminating process PID %d...\n", pid)
-	}
-
-	// Kill the process
-	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-		return fmt.Errorf("failed to kill process %d: %w", pid, err)
-	}
-
-	// Wait for the instance to remove itself from registry
-	if Config.Verbose {
-		fmt.Printf("Waiting for instance to clean up registry entry...\n")
-	}
-	for i := 0; i < 5; i++ {
-		time.Sleep(1 * time.Second)
-		if !registry.HasInstanceAtAddress(address) {
-			if Config.Verbose {
-				fmt.Printf("Instance %s successfully killed and removed from registry.\n", address)
-			}
-
-			// Update default instance if needed
-			instances, err := registry.ListInstancesCleaned(ctx)
-			if err == nil && len(instances) > 0 {
-				// ensureDefaultInstance logic will handle setting a new default
-				defaultInstance := registry.GetDefaultInstance()
-				if defaultInstance == address || defaultInstance == "" {
-					if len(instances) > 0 {
-						if err := registry.SetDefaultInstance(instances[0].Address); err == nil {
-							if Config.Verbose {
-								fmt.Printf("Updated default instance to: %s\n", instances[0].Address)
-							}
-						}
-					}
-				}
-			}
-
-			return nil
-		}
-	}
-
-	return fmt.Errorf("instance killed but failed to remove itself from registry within 5 seconds")
-}
-
-func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
-	if Config.Verbose {
-		fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
-	}
-
-	// Get paths relative to the cline binary location
-	execPath, err := os.Executable()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get executable path: %w", err)
-	}
-	binDir := path.Dir(execPath)
-	installDir := path.Dir(binDir)
-	nodePath := path.Join(binDir, "node")
-	clineCorePath := path.Join(installDir, "cline-core.js")
-
-	// Create logs directory in ~/.cline/logs
-	logsDir := path.Join(Config.ConfigPath, "logs")
-	if err := os.MkdirAll(logsDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	// Create timestamped log file
-	timestamp := time.Now().Format("2006-01-02-15-04-05")
-	logFileName := fmt.Sprintf("cline-core-%s-localhost-%d.log", timestamp, corePort)
-	logFilePath := path.Join(logsDir, logFileName)
-	logFile, err := os.Create(logFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create log file: %w", err)
-	}
-
-	// Start the cline-core process with --config flag
-	args := []string{clineCorePath,
-		"--port", fmt.Sprintf("%d", corePort),
-		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
-		"--config", Config.ConfigPath}
-
-	cmd := exec.Command(nodePath, args...)
-
-	// Set working directory to installation root
-	cmd.Dir = installDir
-
-	// Redirect stdout and stderr to log file
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	// Put the child process in a new process group so Ctrl+C doesn't kill it
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setpgid: true,
-	}
-
-	// Set environment variables with NODE_PATH for node_modules
-	env := os.Environ()
-	env = append(env,
-		fmt.Sprintf("NODE_PATH=%s", path.Join(installDir, "node_modules")),
-		"GRPC_TRACE=all",
-		"GRPC_VERBOSITY=DEBUG",
-		"NODE_ENV=development",
-	)
-	cmd.Env = env
-
-	if err := cmd.Start(); err != nil {
-		logFile.Close()
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Started cline-core (PID: %d)\n", cmd.Process.Pid)
-		fmt.Printf("Logging cline-core output to: %s\n", logFilePath)
-	}
-	return cmd, nil
-}