Merge https://github.com/jc01rho/CLIProxyAPIPlus

Author: leic4u

.sisyphus/notepads/add-trae-aliases/learnings.md

@@ -0,0 +1 @@
+Added model aliases for Trae models to improve client compatibility and discovery.

.sisyphus/notepads/antigravity-ls-migration/decisions.md

@@ -0,0 +1,5 @@
+## 2026-02-20
+
+- SQLite 드라이버는 CGO-free 요구사항을 만족하기 위해 `modernc.org/sqlite`를 선택했다.
+- `ReadVSCDBToken`는 DB 경로 미입력 시 `DefaultVSCDBPath()`를 사용하도록 하여 운영 환경 기본 동작을 보장했다.
+- 토큰 마스킹은 요구사항(앞 4자리만 표시)에 맞춰 `xxxx...` 포맷 전용 헬퍼(`maskTokenPrefix`)를 사용했다.

.sisyphus/notepads/antigravity-ls-migration/issues.md

@@ -0,0 +1,160 @@
+## LS Crash Issue Analysis - 2026-02-20
+
+### Issue Summary
+LS (Language Server) process crashes with "signal: killed" immediately after SendUserCascadeMessage completes successfully (HTTP 200 response received after 33.928s).
+
+---
+
+### Root Cause Identified
+
+**MISSING: StreamCascadeReactiveUpdates subscription**
+
+The ZeroGravity reference implementation (`backend.rs` lines 418-527) maintains an active subscription to `StreamCascadeReactiveUpdates` after sending a cascade message. This is absent in the current implementation.
+
+#### Key Differences from ZeroGravity:
+
+| Aspect | ZeroGravity (Working) | CLIProxy (Crashing) |
+|--------|----------------------|---------------------|
+| Post-Message | Subscribes to reactive updates | No reactive subscription |
+| Stream Reading | Background goroutine consumes chunks | No stream consumer |
+| Protocol | Connect protocol envelope handling | Missing |
+| Connection Lifecycle | Maintains stream connection | Connection may be orphaned |
+
+#### ZeroGravity Reactive Stream Implementation:
+
+```rust
+// backend.rs lines 418-527
+async fn stream_reactive_rpc(
+    &self,
+    rpc_method: &str,
+    cascade_id: &str,
+) -> Result<tokio::sync::mpsc::Receiver<serde_json::Value>, String> {
+    // Uses application/connect+json content-type
+    // Sends envelope: [flags:1][length:4][payload]
+    // Spawns background task to continuously read chunks
+    // Parses Connect protocol frames
+}
+```
+
+---
+
+### Why This Causes Crashes
+
+1. **LS expects active reader**: After SendUserCascadeMessage, the LS likely expects the client to subscribe to reactive updates to receive streaming responses
+2. **Buffer backpressure**: Without a consumer reading the reactive stream, the LS write buffers fill up, potentially causing it to block and eventually be killed
+3. **Missing lifecycle signal**: The reactive stream subscription signals to LS that the client is ready to receive streaming updates
+4. **USS topic insufficient**: Current USS topic subscription in stub server (`uss-oauth`) handles authentication only, not cascade-specific reactive updates
+
+---
+
+### Current State Analysis
+
+**Files examined:**
+
+1. **antigravity_executor.go** (lines 677-850)
+   - `ExecuteStream()` calls `SendUserCascadeMessage` and then reads response body
+   - No reactive update subscription before/during message send
+   - Response body is read as SSE stream, but this is different from reactive updates
+
+2. **ls_client.go**
+   - `SendProto()` sends protobuf requests
+   - No stream subscription capability
+   - HTTP client has 300s response header timeout
+
+3. **ls_process.go**
+   - Handles LS lifecycle (start/stop/healthcheck)
+   - Crash recovery mechanism present but triggered after "signal: killed"
+   - No reactive stream handling
+
+4. **ls_stub_server.go** (lines 164-169)
+   - Handles `SubscribeToUnifiedStateSyncTopic` for USS (oauth token)
+   - Only handles initial state + keepalive
+   - Does NOT handle cascade-specific reactive updates
+
+5. **ls_warmup.go**
+   - Warmup sequence runs initialization RPCs
+   - No reactive stream setup in warmup
+
+---
+
+### Required Fix
+
+**Implement StreamCascadeReactiveUpdates subscription** similar to ZeroGravity:
+
+1. **Add subscription before SendUserCascadeMessage:**
+   - Open streaming connection to `/exa.language_server_pb.LanguageServerService/StreamCascadeReactiveUpdates`
+   - Use `application/connect+json` content-type
+   - Send proper Connect protocol envelope
+
+2. **Background stream reader:**
+   - Spawn goroutine to continuously read chunks
+   - Parse `[flags:1][length:4][payload]` envelope format
+   - Handle both data frames (flags=0x00) and end frames (flags=0x02)
+
+3. **Integration with executor:**
+   - Subscribe when cascade is created
+   - Keep subscription alive during message exchange
+   - Close subscription when cascade completes
+
+---
+
+### Technical Details
+
+**Connect Protocol Frame Format:**
+```
+[1 byte flags] [4 bytes big-endian length] [payload data]
+
+Flags:
+- 0x00 = Data frame (JSON payload)
+- 0x02 = End frame (stream complete)
+```
+
+**Request Format:**
+```json
+{
+  "protocolVersion": 1,
+  "id": "<cascade_id>"
+}
+```
+
+**Headers Required:**
+```
+Content-Type: application/connect+json
+Connect-Protocol-Version: 1
+```
+
+---
+
+### Evidence from ZeroGravity
+
+ZeroGravity's `stream_reactive_rpc()` function:
+- Creates mpsc channel for streaming updates
+- Spawns tokio task to continuously consume chunks
+- Parses Connect protocol frames
+- Sends parsed JSON to channel
+- This keeps the connection alive and LS responsive
+
+---
+
+### Additional Observations
+
+1. **UpdateConversationAnnotations**: ZeroGravity also calls `update_annotations()` after SendUserCascadeMessage (backend.rs lines 207-226) - this might be another fingerprinting issue
+
+2. **Heartbeat**: Current heartbeat runs every ~1s (ls_warmup.go line 77-106) - this is good but not sufficient without reactive subscription
+
+3. **USS Keepalive**: Stub server sends keepalive every 5s for USS topics (ls_stub_server.go line 241-259) - this is correct for USS but unrelated to cascade reactive updates
+
+---
+
+### Conclusion
+
+The LS crash is caused by the **missing reactive updates subscription**. The LS expects a consumer for `StreamCascadeReactiveUpdates` to be active during cascade operations. Without this, the LS likely encounters buffer issues or timeout conditions that result in the process being killed.
+
+**Priority**: HIGH - This is a critical missing feature that causes LS instability
+**Fix Complexity**: MEDIUM - Requires implementing Connect protocol streaming support
+
+### Related Code Locations
+
+- ZeroGravity reference: `/home/jc01rho/git/zerogravity-src/src/backend.rs` lines 418-527
+- Current stub server: `CLIProxyAPIPlus/internal/runtime/executor/ls_stub_server.go`
+- Executor: `CLIProxyAPIPlus/internal/runtime/executor/antigravity_executor.go`

.sisyphus/notepads/antigravity-ls-migration/learnings.md

@@ -0,0 +1,67 @@
+
+
+## 2026-02-20 (Reactive Stream Subscription)
+
+### 구현 개요
+- 파일: `CLIProxyAPIPlus/internal/runtime/executor/ls_reactive_stream.go`
+
+### 문제 배경
+- LS가 SendUserCascadeMessage 후 "signal: killed"로 크래시됨
+- 원인: LS는 cascade 생성 후 reactive updates 스트림 소비자를 기대함
+- 소비자 없으면 LS write buffer가 차서 backpressure 발생 → 프로세스 킬됨
+
+### 해결책: StreamCascadeReactiveUpdates 구독
+ZeroGravity 참조 구현(`backend.rs` lines 418-527)을 Go로 포팅:
+
+**Connect Protocol Frame Format:**
+```
+[1 byte flags] [4 bytes big-endian length] [payload]
+- flags=0x00: data frame (JSON payload)
+- flags=0x02: end frame (stream complete)
+```
+
+**핵심 구현 패턴:**
+
+1. **HTTP 클라이언트 설정 (스트리밍용)**
+   - `http.Client.Timeout = 0` (무제한 - 스트리밍 연결용)
+   - `ResponseHeaderTimeout = 300s` (ls_client.go 패턴과 동일)
+   - `DialContext.Timeout = 10s`
+
+2. **Connect Protocol 요청**
+   - URL: `https://127.0.0.1:{port}/exa.language_server_pb.LanguageServerService/StreamCascadeReactiveUpdates`
+   - Content-Type: `application/connect+json`
+   - Headers: `Connect-Protocol-Version: 1`, `x-codeium-csrf-token`
+   - Body envelope: `[flags:1][length:4][payload]`
+
+3. **백그라운드 고루틴 (핵심)**
+   - `readStream()`이 별도 고루틴에서 지속적으로 chunk 소비
+   - 버퍼에 데이터 축적 후 `processBuffer()`로 frame 단위 파싱
+   - `processFrame()`에서 flags별 처리 (0x00=data, 0x02=end)
+   - 스트림 소비이 목적 - 실제 데이터는 로깅만 함
+
+4. **Integration with Executor**
+   - `createCascadeWithReactiveSubscription()` 헬퍼 추가
+   - 모든 Execute 메서드에서 cascade 생성 직후 구독 시작
+   - `defer subscription.Close()`로 cascade 종료 시 정리
+
+### 수정된 파일
+1. `ls_reactive_stream.go` (새 파일, 261 lines)
+2. `antigravity_executor.go`:
+   - `createCascadeWithReactiveSubscription()` 메서드 추가
+   - `Execute()`: cascade 생성 부분 수정
+   - `executeClaudeNonStream()`: cascade 생성 부분 수정  
+   - `ExecuteStream()`: cascade 생성 부분 수정
+
+### 검증
+```bash
+cd CLIProxyAPIPlus
+go build -o cliproxy ./cmd/server
+# 빌드 성공
+```
+
+### 핵심 학습
+- LS 바이너리는 단순 HTTP 요청-응답이 아닌, 연결 유지형 스트리밍 패턴 요구
+- Reactive updates 스트림 소비는 필수이며 선택사항이 아님
+- Connect Protocol envelope 파싱: `[flags:1][length:4][payload]`
+- Background goroutine으로 지속적 소비 - 메인 플로우 차단 없음
+

.sisyphus/notepads/antigravity-ls-migration/problems.md

@@ -0,0 +1,3 @@
+## 2026-02-20
+
+- 현재 구현은 `ItemTable` 전체 key/value 스캔 방식이므로, 향후 키 스키마가 확정되면 대상 key를 좁혀 성능 최적화 여지가 있다.

.sisyphus/notepads/cline-provider/decisions.md

@@ -0,0 +1,14 @@
+# Cline Provider - Decisions
+
+## 2026-02-18 Task: Architecture Decisions
+- Provider name: "cline" (constant in constant.go)
+- Follow Kilo provider pattern for executor structure
+- OAuth flow uses local callback server (like Claude provider, NOT device flow like Kilo)
+- Token refresh uses RefreshLead of 5 minutes (not nil like Kilo)
+- Executor targets: `https://api.cline.bot/api/v1/chat/completions`
+- Auth format: `Bearer workos:{accessToken}` with workos prefix
+
+## 2026-02-18 Task: OAuth flow compatibility decisions
+- `InitiateOAuth`는 리다이렉트 자동 추적을 끄는 임시 `http.Client`를 사용해 3xx/200 응답을 모두 수용한다.
+- `AuthorizeResponse`는 유지하되 `redirect_url` 필드를 확장해 JSON 응답 변형을 흡수한다.
+- `ExchangeCode(ctx, code, callbackURL)`로 시그니처를 전환하여 토큰 교환 시 `redirect_uri`를 명시적으로 전달한다.

.sisyphus/notepads/cline-provider/issues.md

@@ -0,0 +1,8 @@
+# Cline Provider - Issues
+
+(none yet)
+
+## 2026-02-18 Task: OAuth 400 장애 원인
+- 증상: authorize/token 호출 시 `invalid or missing client_type parameter`로 400 발생.
+- 원인: authorize query/payload가 Cline API 기대 스키마(`client_type=extension` 포함)와 불일치.
+- 해결: authorize 파라미터 및 token exchange payload를 Cline 규격으로 수정, 호출부 시그니처 동기화.

.sisyphus/notepads/cline-provider/learnings.md

@@ -0,0 +1,83 @@
+# Cline Provider - Learnings
+
+## 2026-02-18 Task: Initial Analysis
+- Cline uses OAuth 2.0 via WorkOS for authentication
+- Base URL: `https://api.cline.bot`
+- Auth header format: `Bearer workos:{accessToken}` (CRITICAL: the `workos:` prefix!)
+- Custom headers: `HTTP-Referer: https://cline.bot`, `X-Title: Cline`
+- Chat completion endpoint: `POST /api/v1/chat/completions` (OpenAI-compatible)
+- Token response: `{ success: true, data: { accessToken, refreshToken, expiresAt, userInfo } }`
+- Token refresh: 5 minutes before expiry
+- OAuth callback: local HTTP server on ports 48801-48811
+- Model IDs use OpenRouter format: `anthropic/claude-sonnet-4.6`
+- Free models: `["anthropic/claude-sonnet-4.6", "kwaipilot/kat-coder-pro", "z-ai/glm-5"]`
+- Provider constant should be `"cline"`
+- Kilo provider pattern is the closest reference (device flow vs OAuth, but same executor pattern)
+- Module path: `github.com/router-for-me/CLIProxyAPI/v6`
+- Use `util.NewProxyClient()` or `newProxyAwareHTTPClient()` for HTTP clients
+- Kilo provider executor/auth flow was a useful reference during early Cline implementation analysis.
+
+## 2026-02-18 Task: Cline auth package implementation
+- `internal/auth/cline/cline_token.go` was added following Kilo token persistence pattern exactly (MkdirAll 0700, JSON encode, `misc.LogSavingCredentials`, `Type="cline"`).
+- `ClineTokenStorage` stores `accessToken`, `refreshToken`, `expiresAt`, `email`, `userId`, `displayName`, and `type`.
+- `internal/auth/cline/cline_auth.go` implements WorkOS OAuth flow endpoints:
+  - `GET /api/v1/auth/authorize` with `callbackUrl`
+  - `POST /api/v1/auth/token` with `{code, state}`
+  - `POST /api/v1/auth/refresh` with `{refreshToken}`
+  - `GET /api/v1/users/me` with `Authorization: Bearer workos:{accessToken}`
+- Added local callback server method with automatic fallback over ports `48801..48811` and graceful shutdown after receiving code/state.
+- `expiresAt` parsing supports integer, float, numeric string, and RFC3339/RFC3339Nano timestamp string formats to match possible API variants.
+
+## 2026-02-18 Task: Create cline_models.go
+- Created `/home/jc01rho/git/cli-proxy/CLIProxyAPIPlus/internal/registry/cline_models.go`
+- Followed exact pattern from `kilo_models.go` (same package structure, no imports needed)
+- Function: `GetClineModels() []*ModelInfo`
+- Models defined:
+  - `cline/auto`: Auto model selection with thinking support (200K context, 64K completion)
+  - `anthropic/claude-sonnet-4.6`: Claude Sonnet 4.6 via Cline (200K context, 64K completion, thinking support)
+  - `kwaipilot/kat-coder-pro`: KAT Coder Pro via Cline (128K context, 32K completion)
+  - `z-ai/glm-5`: GLM-5 via Cline (128K context, 32K completion)
+- All models have Type="cline", OwnedBy="cline"
+- No LSP errors in the created file
+
+## 2026-02-18 Task: Create cline_executor.go
+- Created `/home/jc01rho/git/cli-proxy/CLIProxyAPIPlus/internal/runtime/executor/cline_executor.go`
+- Followed exact pattern from kilo_executor.go (same structure and method organization)
+- Key implementations:
+  - `ClineExecutor` struct with config
+  - `NewClineExecutor()` constructor
+  - `Identifier()` returns "cline"
+  - `PrepareRequest()` - applies Cline headers with workos: prefix
+  - `HttpRequest()` - raw HTTP request execution
+  - `Execute()` - non-streaming chat completion
+  - `ExecuteStream()` - streaming chat completion with SSE handling
+  - `Refresh()` - placeholder (returns auth as-is, will be enhanced when cline auth package is ready)
+  - `CountTokens()` - returns unsupported error (matching Kilo pattern)
+  - `clineCredentials()` - extracts tokens from auth metadata/attributes
+  - `applyClineHeaders()` - sets required headers including Authorization: Bearer workos:{token}
+  - `FetchClineModels()` - dynamic model fetching from Cline API
+- Critical implementation details:
+  - Authorization header uses `Bearer workos:` prefix (CRITICAL for Cline API)
+  - Custom headers: HTTP-Referer: https://cline.bot, X-Title: Cline
+  - API endpoint: https://api.cline.bot/api/v1/chat/completions
+  - Uses existing executor package utilities (newProxyAwareHTTPClient, newUsageReporter, parseOpenAIUsage, etc.)
+- File compiles successfully with existing codebase (verified with go build)
+- All comments follow Go docstring conventions matching kilo_executor.go pattern
+
+## 2026-02-18 Task: Integrate Cline into registration wiring (6-file surgical update)
+- Registration touched exactly 6 existing files, following Kilo registration pattern with minimal deltas.
+- `internal/constant/constant.go`: added `Cline = "cline"` constant for provider identity consistency.
+- `internal/cmd/auth_manager.go`: registered `sdkAuth.NewClineAuthenticator()` in manager constructor list.
+- `sdk/auth/refresh_registry.go`: added refresh lead registration for `cline` using `NewClineAuthenticator()`.
+- `internal/registry/model_definitions.go`: wired `case "cline"` in static channel lookup and included `GetClineModels()` in global static lookup slice.
+- `sdk/cliproxy/service.go`: wired executor registration (`NewClineExecutor`) and dynamic model fetch path (`FetchClineModels`).
+- `sdk/cliproxy/auth/oauth_model_alias.go`: added `cline` to OAuth model-alias-supported providers.
+- Build verification passed with `go build ./cmd/server` from `CLIProxyAPIPlus`.
+- LSP diagnostics tool in this session reports workspace-scoping warnings (`No active builds contain ...`) rather than code issues; build success served as functional compile verification.
+
+## 2026-02-18 Task: Cline OAuth 파라미터/토큰 교환 정합성 수정
+- `/api/v1/auth/authorize` 호출 시 Cline은 `callbackUrl`이 아니라 `client_type=extension`, `callback_url`, `redirect_uri`를 기대한다.
+- authorize 응답은 환경에 따라 두 형태가 가능하다: (1) HTTP 3xx + `Location` 헤더, (2) 200 JSON + `redirect_url`/`url`.
+- OAuth state는 JSON의 `state`가 있으면 우선 사용하고, 없으면 redirect URL query의 `state`를 파싱하며, 둘 다 없을 때만 fallback 생성이 안전하다.
+- `/api/v1/auth/token` 교환은 `{grant_type, code, client_type, redirect_uri}` 조합이 필요하며 기존 `state` 기반 payload는 400 원인이 된다.
+- `ExchangeCode` 시그니처가 `callbackURL` 기반으로 바뀌면 SDK/관리 핸들러 호출부도 함께 맞춰야 컴파일 및 런타임 일관성이 유지된다.

.sisyphus/notepads/cline-provider/problems.md

@@ -0,0 +1,3 @@
+# Cline Provider - Problems
+
+(none yet)

.sisyphus/notepads/kilocode-api-research/decisions.md

@@ -0,0 +1,36 @@
+# Kilocode API Research - Key Decisions
+
+## Free Model Detection Strategy
+Based on research, free models can be identified by:
+
+1. **Primary Method**: Check `pricing` object fields
+   - `pricing.prompt === "0"`
+   - `pricing.completion === "0"`
+   - Both conditions should be true for a model to be considered free
+
+2. **Secondary Method**: Model name contains "(free)" suffix
+   - Some models explicitly marked as "(free)" in their names
+   - Examples: "Qwen3 Coder (free)", "GLM 4.5 Air (free)"
+
+3. **Fallback Method**: Check if all pricing fields are "0"
+   - `pricing.request === "0"`
+   - `pricing.image === "0"`
+
+## API Integration Approach
+- Use existing `getOpenRouterModels()` function pattern
+- Endpoint: `https://api.kilo.ai/api/openrouter/v1/models`
+- Authentication: Bearer token with Kilocode JWT
+- Response format follows OpenRouter standard
+
+## Model Registration Logic
+Filter models where:
+```javascript
+model.pricing && 
+model.pricing.prompt === "0" && 
+model.pricing.completion === "0"
+```
+
+## Error Handling
+- Handle cases where pricing object might be missing
+- Graceful fallback if API is unavailable
+- Log warnings for unexpected response formats