From bcbdd24efbfb334b73a8f757886e7477918675d2 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 5 Mar 2026 04:36:15 +0000 Subject: [PATCH 01/16] docs: add Claude CLI integration analysis for bridge approach Comprehensive analysis of mapping Claude CLI's stream-json output to Codex frontend's 30 JSON-RPC events, covering approval flow, item types, and implementation plan for the D-NEW bridge binary. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- docs/claude-cli-integration-analysis.md | 233 ++++++++++++++++++++++++ 1 file changed, 233 insertions(+) create mode 100644 docs/claude-cli-integration-analysis.md diff --git a/docs/claude-cli-integration-analysis.md b/docs/claude-cli-integration-analysis.md new file mode 100644 index 000000000..83ff79353 --- /dev/null +++ b/docs/claude-cli-integration-analysis.md @@ -0,0 +1,233 @@ +# Claude CLI Integration Analysis + +## Overview + +This document summarizes the analysis of integrating Claude CLI as a backend provider for the Codex GUI, focusing on approach D (Bridge Binary) and its sub-variants. + +--- + +## Architecture Context + +### Current Codex Architecture +- **Frontend** (React/Electron) communicates via JSON-RPC over stdio with **Backend** (codex-rs binary) +- Backend manages Claude API sessions, tool execution, approval flow +- Frontend expects ~30 event types with specific data structures + +### Goal +Replace the Codex backend with Claude CLI while preserving the existing frontend unchanged. + +--- + +## Approach D: Bridge Binary + +A standalone binary that wraps Claude CLI and translates its protocol into the Codex JSON-RPC protocol expected by the frontend. + +### Sub-variants Analyzed + +| Variant | Description | Merge Conflicts | Complexity | Testability | +|---------|------------|----------------|------------|-------------| +| **D1** | Separate Rust binary in new crate | Zero | Medium | High | +| **D2** | New mode inside codex-rs binary | High (touches codex-rs) | Medium-High | Medium | +| **D3** | TypeScript bridge (Node.js) | Low | Low-Medium | Medium | +| **D-NEW** | Bridge binary + Backend Mode API | Zero | Medium | Highest | + +### Recommended: D-NEW (Bridge Binary with Backend Mode) + +The bridge binary uses Claude CLI's `--output-format stream-json` to receive structured events, maps them to the Codex JSON-RPC protocol, and communicates with the frontend over stdio. + +**Key advantages:** +- Zero merge conflicts with existing codebase +- Testable in isolation +- Clean separation of concerns +- Reusable for other CLI agent backends + +--- + +## Frontend Event Protocol Analysis + +### Supported Events (30 total) + +The frontend dispatches events through `useAppServerEvents.ts`, which routes raw server methods to specific handlers. + +### Easy Mapping (~15 events) + +These events have simple ID/status fields and map directly: + +| Server Method | Handler Parameters | Notes | +|--------------|-------------------|-------| +| `codex/connected` | `workspaceId: string` | Connection established | +| `thread/started` | `workspaceId, thread: Record` | Thread has `id`, `preview?`, `source?` | +| `thread/archived` | `workspaceId, threadId` | Simple ID | +| `thread/unarchived` | `workspaceId, threadId` | Simple ID | +| `thread/closed` | `workspaceId, threadId` | Resets processing state | +| `turn/started` | `workspaceId, threadId, turnId` | Marks processing | +| `turn/completed` | `workspaceId, threadId, turnId` | Clears processing | +| `thread/name/updated` | `workspaceId, { threadId, threadName }` | Name defaults to null if empty | +| `thread/status/changed` | `workspaceId, threadId, status` | Status type normalized to lowercase | +| `thread/tokenUsage/updated` | `workspaceId, threadId, tokenUsage` | Token stats object | +| `item/agentMessage/delta` | `{ workspaceId, threadId, itemId, delta }` | **Most important** - text streaming | +| `item/reasoning/summaryTextDelta` | `workspaceId, threadId, itemId, delta` | Reasoning stream | +| `item/reasoning/summaryPartAdded` | `workspaceId, threadId, itemId` | Section boundary | +| `item/reasoning/textDelta` | `workspaceId, threadId, itemId, delta` | Full reasoning | +| `item/plan/delta` | `workspaceId, threadId, itemId, delta` | Plan text | + +### Medium Mapping (~10 events) + +These require constructing proper objects or tracking some state: + +| Server Method | Complexity | Notes | +|--------------|-----------|-------| +| `item/started` | Need `item` object with correct `type` field | Types: agentMessage, commandExecution, fileChange, etc. | +| `item/completed` | Same as started + status field | `status: "inProgress" \| "completed"` | +| `turn/plan/updated` | Need `{explanation, plan}` with `steps[].status` | Plan step tracking | +| `turn/diff/updated` | Diff string | From Claude's file edits | +| `account/rateLimits/updated` | Rate limit object | From Claude's headers | +| `item/commandExecution/outputDelta` | Need itemId for tool use | Link to correct tool item | +| `item/fileChange/outputDelta` | Need itemId for file op | Link to correct file item | + +### Hard Mapping (~5 events) + +These require stateful bidirectional communication: + +| Server Method | Complexity | Notes | +|--------------|-----------|-------| +| **Approval flow** | Bidirectional with `request_id` | See detailed section below | +| **`item/tool/requestUserInput`** | Complex questions/options structure | Needs `questions[].id, header, question, options[]` | +| **`error` with `willRetry`** | Retry semantics | Need to understand Claude's retry behavior | + +--- + +## Approval Flow (Detailed) + +The approval flow is the most complex mapping requirement. + +### Frontend Expectation + +```typescript +// Incoming approval request +ApprovalRequest { + workspace_id: string; + request_id: string | number; // For response correlation + method: string; // Command method + params: Record; +} + +// Response back to server +respondToServerRequest(workspace_id, request_id, "accept" | "reject") +``` + +### Claude CLI Side + +Claude CLI emits `permission_request` events when tool use requires approval, and expects `permission_response` back via stdin. + +### Bridge Mapping + +1. Intercept Claude `permission_request` event +2. Assign a JSON-RPC `id` for correlation +3. Send as approval event to frontend: `{"id": 42, "method": "...", "params": {...}}` +4. Receive frontend response: `{"id": 42, "result": {"approved": true}}` +5. Forward approval/rejection to Claude CLI + +This is stateful but straightforward in a bridge binary. + +--- + +## Frontend Data Structure Details + +### Item Types + +| Type | Description | Special Handling | +|------|------------|-----------------| +| `enteredReviewMode` | User enters review | Marks thread as reviewing | +| `exitedReviewMode` | User exits review | Marks thread as not reviewing | +| `contextCompaction` | Memory optimization | Shows inProgress/completed status | +| `webSearch` | Search result | Shows inProgress/completed status | +| `agentMessage` | LLM response | Triggers user message callback | +| `commandExecution` | Tool execution | Has output delta stream | +| `fileChange` | File modification | Has output delta stream | +| `reasoning` | Internal reasoning | Has text delta stream | +| `plan` | Agent's planned steps | Has delta stream | + +### Key Format Flexibility + +- Frontend supports both camelCase and snake_case: `threadId` / `thread_id` +- All ID fields converted to strings with empty string fallback +- String values trimmed of whitespace +- Status type normalized: lowercase, spaces/underscores/hyphens removed + +--- + +## Claude CLI Output Format + +With `--output-format stream-json`, Claude CLI emits newline-delimited JSON: + +```jsonl +{"type": "system", "subtype": "init", ...} +{"type": "assistant", "subtype": "text_delta", "text": "..."} +{"type": "assistant", "subtype": "tool_use", "tool": "Bash", "input": {...}} +{"type": "result", "subtype": "tool_result", ...} +{"type": "assistant", "subtype": "text_done", "text": "..."} +``` + +### Mapping to Codex Events + +| Claude Event | Codex Event | +|-------------|-------------| +| `system/init` | `codex/connected` + `thread/started` | +| `assistant/text_delta` | `item/agentMessage/delta` | +| `assistant/text_done` | `item/completed` (agentMessage) | +| `assistant/tool_use` | `item/started` (commandExecution/fileChange) | +| `result/tool_result` | `item/completed` + output deltas | +| `assistant/thinking_delta` | `item/reasoning/textDelta` | +| Permission request | Approval flow (see above) | + +--- + +## Mapping Coverage Summary + +- **~80%** of events map trivially or with moderate effort +- **~20%** (tool execution, file changes, approval) require careful state management +- This complexity is **equal across all D variants** - the mapping logic is the same regardless of implementation language or architecture + +--- + +## Implementation Plan (D-NEW) + +### Phase 1: Core Bridge +1. New Rust crate `claude-bridge/` with own `Cargo.toml` +2. Spawn Claude CLI with `--output-format stream-json` +3. Parse NDJSON stream, map to Codex JSON-RPC +4. Emit events to stdout for frontend consumption + +### Phase 2: Essential Events +1. Thread lifecycle (started/closed/status) +2. Turn lifecycle (started/completed) +3. Agent message streaming (delta/completed) +4. Basic item tracking with generated IDs + +### Phase 3: Tool Execution & Approval +1. Tool use → item started/completed mapping +2. Permission request → approval flow with request_id correlation +3. File change detection and output streaming + +### Phase 4: Polish +1. Token usage tracking +2. Error handling with retry semantics +3. Thread naming from first message preview +4. Rate limit forwarding + +--- + +## Files Analyzed + +### Frontend (React) +- `codex-rs/web/src/hooks/useAppServerEvents.ts` — Main event router (30 methods) +- `codex-rs/web/src/hooks/useThreadApprovalEvents.ts` — Approval flow +- `codex-rs/web/src/hooks/useThreadItemEvents.ts` — Item/message streaming +- `codex-rs/web/src/hooks/useThreadTurnEvents.ts` — Turn/thread lifecycle +- `codex-rs/web/src/hooks/useThreadUserInputEvents.ts` — User input requests + +### Backend (Rust) +- `codex-rs/core/src/protocol.rs` — JSON-RPC protocol definitions +- `codex-rs/core/src/client_common.rs` — Client event handling +- `codex-rs/exec/src/event_handler.rs` — Server-side event emission From 2bbbd9b115b94d5a949220fefb3541f9840a8cea Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 04:50:01 +0000 Subject: [PATCH 02/16] docs: add Claude CLI integration implementation plan MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Detailed plan for integrating Claude CLI as an alternative backend: - Bridge binary architecture (claude-bridge) translating stream-json to JSON-RPC - 4-phase implementation: core streaming, tool execution, approval flow, polish - Event mapping reference (Claude events → Codex protocol) - Dual-mode support: both backends selectable in Settings UI - Auto-detect Claude CLI from PATH - MVP available after Phase 1 with basic message streaming --- docs/claude-cli-integration-plan.md | 397 ++++++++++++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 docs/claude-cli-integration-plan.md diff --git a/docs/claude-cli-integration-plan.md b/docs/claude-cli-integration-plan.md new file mode 100644 index 000000000..7afebe074 --- /dev/null +++ b/docs/claude-cli-integration-plan.md @@ -0,0 +1,397 @@ +# Claude CLI Integration Implementation Plan + +## Context + +**Problem:** CodeAgentMonitor currently depends on Codex backend (codex app-server). We need to integrate Claude CLI as an alternative backend to reduce external dependencies. + +**Goal:** Replace Codex backend with Claude CLI while keeping the frontend unchanged by building a bridge binary that translates Claude CLI's stream-json output to the Codex JSON-RPC protocol. + +**Why This Approach:** Minimizes changes to existing codebase, reuses proven patterns (EventSink trait, process management, JSON-RPC protocol), and maintains feature parity with existing backend. + +--- + +## Architecture Decision: Bridge Binary (D-NEW) + +A standalone binary (`claude-bridge`) that: +1. Spawns Claude CLI with `--output-format stream-json` +2. Parses newline-delimited JSON events +3. Maps Claude events to Codex JSON-RPC protocol +4. Communicates with frontend via EventSink trait +5. Handles bidirectional approval flow with request_id correlation + +**Why:** Zero merge conflicts, testable in isolation, reusable for other CLI backends. + +--- + +## Implementation Phases + +### Phase 1: Core Bridge Binary & Basic Event Streaming (Weeks 1-2) + +**Objectives:** +- New binary skeleton in `src-tauri/src/bin/claude_bridge.rs` +- Parse Claude CLI stream-json output +- Map essential events to Codex format +- Handle thread lifecycle + +**Critical Files to Create/Modify:** +- `src-tauri/src/bin/claude_bridge.rs` (NEW) — Bridge binary main +- `src-tauri/src/bin/claude_bridge/event_mapper.rs` (NEW) — Event mapping logic +- `src-tauri/src/bin/claude_bridge/process.rs` (NEW) — Claude CLI process management +- `src-tauri/Cargo.toml` (MODIFY) — Add claude-bridge binary + +**Key Tasks:** +1. Scaffold bridge binary with process spawning (tokio::process::Command) +2. Read Claude's stream-json output line-by-line +3. Parse JSON and extract event type +4. Map basic events: + - `system/init` → `codex/connected` + `thread/started` + - `assistant/text_delta` → `item/agentMessage/delta` + - `assistant/text_done` → `item/completed` +5. Handle workspace/thread ID generation and tracking +6. Emit events via stdin back to parent process (Codex JSON-RPC format) + +**Testing:** +- Unit tests for event mapping (mock JSON input, verify output) +- Integration test spawning dummy Claude CLI and reading output +- Test with real Claude CLI if available + +**Verification:** +- Bridge accepts JSON-RPC requests and forwards to Claude CLI stdin +- Bridge reads Claude events and outputs Codex JSON-RPC notifications +- Basic agent message streaming works end-to-end + +--- + +### Phase 2: Tool Execution & Item Management (Weeks 3-4) + +**Objectives:** +- Map Claude tool use events to Codex item structure +- Track itemId correlation for streaming outputs +- Generate realistic item structures + +**Critical Files:** +- `src-tauri/src/bin/claude_bridge/item_tracker.rs` (NEW) — Item ID generation and tracking +- Extend `event_mapper.rs` with tool execution logic + +**Key Tasks:** +1. Add itemId generation and correlation tracking (use UUID) +2. Map `assistant/tool_use` → `item/started` (commandExecution/fileChange) +3. Map `result/tool_result` → output delta streams + `item/completed` +4. Handle file change detection (diff output) +5. Support streaming outputs: + - `item/commandExecution/outputDelta` + - `item/fileChange/outputDelta` + +**Item Types to Support:** +- `commandExecution` (tool execution) +- `fileChange` (file modifications with diff) + +**Testing:** +- Mock tool use events with various output streams +- Test item lifecycle (started → delta → delta → completed) +- Verify item IDs are unique and consistent + +**Verification:** +- Tool execution appears as items in frontend +- Streaming output renders progressively +- File changes show diffs correctly + +--- + +### Phase 3: Approval Flow & Bidirectional Communication (Weeks 5-6) + +**Objectives:** +- Implement stateful approval request/response correlation +- Handle Claude CLI permission requests +- Route frontend approvals back to Claude + +**Critical Files:** +- `src-tauri/src/bin/claude_bridge/approval_handler.rs` (NEW) — Approval state machine +- `src-tauri/src/bin/claude_bridge/request_router.rs` (NEW) — ID correlation logic + +**Key Tasks:** +1. Track pending approval requests with request_id ↔ Claude event correlation +2. Map `permission_request` (Claude) → `item/tool/requestApproval` (Codex) +3. Assign JSON-RPC ID to each approval request for correlation +4. Store mapping: `{id: request_id, claude_state: ...}` +5. Route frontend `respond_to_server_request(workspace_id, request_id, result)` back to Claude +6. Support approval allowlist forwarding (auto-accept matching commands) + +**State Machine:** +- Approval request received → assign ID, emit to frontend +- Frontend approval response → lookup mapping, send to Claude CLI stdin +- Claude stdin format: `{"approved": true/false}` or similar + +**Testing:** +- Mock approval requests and responses +- Test request_id correlation across multiple pending requests +- Test timeout handling (what if frontend never responds?) + +**Verification:** +- Approval dialog appears in frontend for tool execution +- Frontend approval/rejection blocks CLI correctly +- Multiple concurrent approvals are tracked independently + +--- + +### Phase 4: Polish & Integration (Weeks 7-8) + +**Objectives:** +- Handle edge cases and error scenarios +- Token usage tracking +- Rate limit forwarding +- Integration with Tauri IPC + +**Critical Files:** +- `src-tauri/src/codex/mod.rs` (MODIFY) — Add claude-bridge spawning logic +- `src-tauri/src/backend/mod.rs` (MODIFY) — Dual-mode support +- `.github/workflows/ci.yml` (MODIFY) — Add bridge tests +- `.github/workflows/release.yml` (MODIFY) — Add daemon binary build + +**Key Tasks:** +1. **Error Handling:** + - Claude CLI not found → emit helpful error to frontend + - Stream parse errors → emit `codex/parseError` events + - Process exit → emit `thread/closed` for cleanup + +2. **Token Usage:** Map Claude's token counts to `thread/tokenUsage/updated` + +3. **Rate Limits:** Forward from Claude headers to `account/rateLimits/updated` + +4. **Thread Naming:** Use first message preview (first 38 chars) for thread name + +5. **Dual-Mode Integration:** + - Settings UI dropdown: "Backend: Codex / Claude CLI" + - Auto-detect `claude` from PATH (no env var needed) + - Default: Codex (backward compatible) + - Persist selection in app settings store + +6. **CI/CD Integration:** + - Add `cargo test` for bridge binary in CI + - Build bridge binary in release workflow + - Platform-specific handling (Windows exe, macOS/Linux binary) + +7. **Documentation:** + - Update README with Claude CLI backend option + - Add troubleshooting guide for common errors + - Document event mapping in docs/app-server-events.md + +**Testing:** +- End-to-end integration with frontend (if possible with mock) +- Error scenario testing (missing CLI, parse errors, timeout) +- Stress test with large streaming outputs + +**Verification:** +- Bridge binary builds on all platforms (macOS, Linux, Windows) +- CI/CD tests pass +- Release binary includes bridge +- Feature flag works (can switch backends) +- No regression in existing Codex functionality + +--- + +## Key Implementation Patterns (Reuse from Existing Code) + +### 1. Process Management +**Source:** `src-tauri/src/backend/app_server.rs` (lines 494-542, 970+) +```rust +// Use this pattern for spawning Claude CLI +let mut child = Command::new("claude") + .arg("chat") + .arg("--output-format") + .arg("stream-json") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn()?; + +// Wrap in Mutex for thread-safe stdin +let stdin = Mutex::new(child.stdin.take().unwrap()); + +// Read with BufReader line-by-line +let stdout = child.stdout.take().unwrap(); +let reader = BufReader::new(stdout); +for line in reader.lines() { + let json: Value = serde_json::from_str(&line)?; + // Process event +} +``` + +### 2. Request-Response Correlation +**Source:** `src-tauri/src/remote_backend/transport.rs` (lines 95-147) +```rust +// Use atomic ID counter +static REQUEST_ID: AtomicU64 = AtomicU64::new(0); + +// Store pending requests +let mut pending: HashMap> = HashMap::new(); +let mut context: HashMap = HashMap::new(); + +// For responses +if let Some(tx) = pending.remove(&id) { + let _ = tx.send(value); +} +``` + +### 3. Event Emission +**Source:** `src-tauri/src/backend/events.rs` +```rust +// Emit via EventSink trait (already defined) +pub trait EventSink: Clone + Send + Sync + 'static { + fn emit_app_server_event(&self, event: AppServerEvent); +} + +// Create bridge-specific implementation or reuse existing +let event = AppServerEvent { + workspace_id: "workspace-1".to_string(), + message: serde_json::json!({ + "method": "thread/started", + "params": { /* ... */ } + }), +}; +event_sink.emit_app_server_event(event); +``` + +### 4. Error Handling +**Source:** `src-tauri/src/backend/app_server.rs` (lines 1032-1047) +```rust +// Emit parse errors to frontend +let parse_error_event = serde_json::json!({ + "method": "codex/parseError", + "params": { + "line": line.to_string(), + "error": err.to_string(), + } +}); +``` + +--- + +## Event Mapping Reference + +### Simple 1:1 Mappings +| Claude Event | Codex Event | Notes | +|---|---|---| +| `system/init` | `codex/connected` + `thread/started` | Emit both on startup | +| `assistant/text_delta` | `item/agentMessage/delta` | Stream text | +| `assistant/text_done` | `item/completed` | Mark message done | +| `assistant/thinking_delta` | `item/reasoning/textDelta` | Thinking output | + +### Complex Mappings +| Claude Event | Codex Event(s) | Implementation | +|---|---|---| +| `assistant/tool_use` | `item/started` (commandExecution) | Generate itemId, track item type | +| `result/tool_result` | `item/commandExecution/outputDelta` + `item/completed` | Stream output, mark done | +| `permission_request` | `item/tool/requestApproval` | ID correlation, bidirectional | + +--- + +## File Structure + +``` +src-tauri/ +├── src/ +│ ├── bin/ +│ │ └── claude_bridge.rs (main binary - ~400 lines) +│ │ ├── event_mapper.rs (event translation - ~300 lines) +│ │ ├── process.rs (Claude process mgmt - ~200 lines) +│ │ ├── item_tracker.rs (item correlation - ~150 lines) +│ │ ├── approval_handler.rs (approval flow - ~200 lines) +│ │ ├── request_router.rs (ID routing - ~100 lines) +│ │ └── mod.rs (exports) +│ ├── codex/mod.rs (MODIFY - add claude-bridge option) +│ └── [other existing modules] +└── Cargo.toml (MODIFY - add binary) +``` + +--- + +## Testing Strategy + +### Unit Tests +- Location: `src-tauri/src/bin/claude_bridge/` (co-located with modules) +- Focus: Event mapping logic, ID correlation, approval state machine +- Mock Claude JSON input, verify Codex JSON-RPC output + +### Integration Tests +- Location: `src-tauri/tests/claude_bridge_integration.rs` (NEW) +- Focus: Process spawning, stream reading, full event flow +- Mock Claude CLI subprocess with predetermined output + +### Manual Testing +- Run with real Claude CLI and frontend +- Test approval flow interactively +- Verify all 30 event types appear correctly + +### CI/CD +- Add to `.github/workflows/ci.yml`: `cargo test --lib --bin claude_bridge` +- Build in release workflow as daemon-like binary + +--- + +## Dependencies to Add + +In `src-tauri/Cargo.toml`: +- Already available: tokio, serde_json, uuid (for itemId) +- No new major dependencies needed + +--- + +## Timeline + +| Phase | Duration | MVP Complete | Testable | +|-------|----------|--------------|----------| +| 1: Core Streaming | Weeks 1-2 | 50% (basic events) | ✓ Unit tests | +| 2: Tool Execution | Weeks 3-4 | 75% (tools working) | ✓ Integration tests | +| 3: Approval Flow | Weeks 5-6 | 95% (all critical paths) | ✓ E2E with frontend | +| 4: Polish & Deploy | Weeks 7-8 | 100% (production-ready) | ✓ CI/CD tests | + +**MVP Definition (End of Phase 2):** Basic Claude CLI agent conversation with message streaming and tool execution visible in frontend. + +**Production Ready (End of Phase 4):** Full feature parity with Codex backend, all events mapped, approval flow working, dual-mode support with flag. + +--- + +## Success Criteria + +1. ✓ Bridge binary compiles and runs +2. ✓ Claude CLI spawns and connects +3. ✓ Agent messages stream to frontend in real-time +4. ✓ Tool execution appears as items with outputs +5. ✓ Approval dialog appears for tool approvals +6. ✓ Frontend approval/rejection controls Claude execution +7. ✓ All 30 Codex events are mapped or explicitly handled +8. ✓ No regression in existing Codex backend functionality +9. ✓ CI/CD tests pass on all platforms +10. ✓ Feature toggle (USE_CLAUDE_CLI) works as expected + +--- + +## Known Risks & Mitigations + +| Risk | Mitigation | +|------|-----------| +| Claude CLI not installed | Check PATH, emit helpful error to user | +| Complex approval state conflicts | Use atomic operations, extensive testing | +| Performance degradation | Profile streaming paths, optimize JSON parsing | +| Platform-specific issues | Test on macOS, Linux, Windows CI | +| Breaking Claude CLI changes | Version pin, handle gracefully with fallback | + +--- + +## Decisions (Confirmed) + +1. **Configuration:** Auto-detect Claude CLI from PATH. No additional config needed. + +2. **Dual-mode support:** Both backends available, user selects in Settings UI. + - Settings page gets a "Backend" dropdown: "Codex" / "Claude CLI" + - Default: Codex (existing behavior preserved) + - Selection persisted in app settings + +3. **Feature availability:** Available after Phase 1 (MVP). + - Basic message streaming usable immediately + - Tools and approval flow added incrementally in later phases + - Users can switch back to Codex if Claude CLI lacks features + +4. **Testing:** Mock Claude CLI output for unit/integration tests. + - Real Claude CLI used for manual testing only From b9078bc1af5867bc5ef962a4ac1a39622150dece Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 05:19:01 +0000 Subject: [PATCH 03/16] feat: Phase 1 - Claude CLI bridge integration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implement core Claude CLI bridge that translates between Claude CLI's stream-json output format and the Codex JSON-RPC protocol used by the frontend. This allows using Claude CLI as an alternative backend. New modules: - claude_bridge/types.rs: Claude CLI stream-json event type definitions - claude_bridge/event_mapper.rs: Maps Claude events to Codex JSON-RPC notifications (system, content blocks, tool use, thinking, results) - claude_bridge/process.rs: Spawns Claude CLI session and wires up event translation via request interceptor pattern Key changes: - WorkspaceSession: Added request_interceptor field for protocol translation without modifying the session's public API - BackendMode: Added 'claude' variant for Settings UI selection - codex/mod.rs: Routes to Claude bridge when BackendMode::Claude Event mappings implemented: - system → codex/connected + thread/started - content_block_start/delta/stop → item/started, delta, completed - text_delta → item/agentMessage/delta - thinking_delta → item/reasoning/textDelta - tool_use → item/commandExecution (started/delta/completed) - message_delta → thread/tokenUsage/updated - result → turn/completed + thread/name/updated All 206 existing tests pass + 20 new tests for event mapping and request interception. --- src-tauri/src/backend/app_server.rs | 35 +- src-tauri/src/bin/codex_monitor_daemon.rs | 1 + src-tauri/src/claude_bridge/event_mapper.rs | 600 ++++++++++++++++++ src-tauri/src/claude_bridge/mod.rs | 3 + src-tauri/src/claude_bridge/process.rs | 500 +++++++++++++++ src-tauri/src/claude_bridge/types.rs | 261 ++++++++ src-tauri/src/codex/mod.rs | 19 +- src-tauri/src/lib.rs | 1 + .../src/shared/workspaces_core/connect.rs | 1 + .../workspaces_core/runtime_codex_args.rs | 1 + src-tauri/src/types.rs | 4 +- 11 files changed, 1421 insertions(+), 5 deletions(-) create mode 100644 src-tauri/src/claude_bridge/event_mapper.rs create mode 100644 src-tauri/src/claude_bridge/mod.rs create mode 100644 src-tauri/src/claude_bridge/process.rs create mode 100644 src-tauri/src/claude_bridge/types.rs diff --git a/src-tauri/src/backend/app_server.rs b/src-tauri/src/backend/app_server.rs index 385970161..ee542019c 100644 --- a/src-tauri/src/backend/app_server.rs +++ b/src-tauri/src/backend/app_server.rs @@ -431,6 +431,17 @@ fn build_initialize_params(client_version: &str) -> Value { const REQUEST_TIMEOUT: Duration = Duration::from_secs(300); +/// Describes how the request interceptor wants to handle a JSON-RPC message. +pub(crate) enum InterceptAction { + /// Write the given string to stdin (potentially translated from the original). + Forward(String), + /// Immediately resolve with this response (don't write to stdin). + /// The response must include an "id" field matching the request. + Respond(Value), + /// Drop the message silently. + Drop, +} + pub(crate) struct WorkspaceSession { pub(crate) codex_args: Option, pub(crate) child: Mutex, @@ -445,6 +456,11 @@ pub(crate) struct WorkspaceSession { pub(crate) owner_workspace_id: String, pub(crate) workspace_ids: Mutex>, pub(crate) workspace_roots: Mutex>, + /// Optional request interceptor for alternative backends (e.g. Claude CLI bridge). + /// When set, JSON-RPC messages are passed through this function before being + /// written to stdin. The interceptor can translate, respond immediately, or drop. + pub(crate) request_interceptor: + Option InterceptAction + Send + Sync>>, } impl WorkspaceSession { @@ -482,8 +498,24 @@ impl WorkspaceSession { } async fn write_message(&self, value: Value) -> Result<(), String> { + let line = if let Some(ref interceptor) = self.request_interceptor { + match interceptor(value) { + InterceptAction::Forward(translated) => translated, + InterceptAction::Respond(response) => { + if let Some(id) = response.get("id").and_then(|v| v.as_u64()) { + if let Some(tx) = self.pending.lock().await.remove(&id) { + let _ = tx.send(response); + } + } + return Ok(()); + } + InterceptAction::Drop => return Ok(()), + } + } else { + serde_json::to_string(&value).map_err(|e| e.to_string())? + }; let mut stdin = self.stdin.lock().await; - let mut line = serde_json::to_string(&value).map_err(|e| e.to_string())?; + let mut line = line; line.push('\n'); stdin .write_all(line.as_bytes()) @@ -791,6 +823,7 @@ pub(crate) async fn spawn_workspace_session( entry.id.clone(), normalize_root_path(&entry.path), )])), + request_interceptor: None, }); let session_clone = Arc::clone(&session); diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs index b0ad4ca73..ede4a3df7 100644 --- a/src-tauri/src/bin/codex_monitor_daemon.rs +++ b/src-tauri/src/bin/codex_monitor_daemon.rs @@ -1670,6 +1670,7 @@ mod tests { background_thread_callbacks: Mutex::new(HashMap::new()), workspace_ids: Mutex::new(HashSet::from([owner_workspace_id.clone()])), workspace_roots: Mutex::new(HashMap::new()), + request_interceptor: None, owner_workspace_id, }) } diff --git a/src-tauri/src/claude_bridge/event_mapper.rs b/src-tauri/src/claude_bridge/event_mapper.rs new file mode 100644 index 000000000..f4a89ac15 --- /dev/null +++ b/src-tauri/src/claude_bridge/event_mapper.rs @@ -0,0 +1,600 @@ +use serde_json::{json, Value}; + +use super::types::{ + BridgeState, ClaudeEvent, ContentBlock, ContentBlockDelta, +}; + +/// Maps a Claude CLI stream-json event to zero or more Codex JSON-RPC +/// notification messages. Returns a `Vec` because some Claude events +/// expand into multiple Codex notifications (e.g. system init → +/// codex/connected + thread/started). +pub(crate) fn map_event(event: &ClaudeEvent, state: &mut BridgeState) -> Vec { + match event { + ClaudeEvent::System(sys) => map_system(sys, state), + ClaudeEvent::MessageStart(msg) => map_message_start(msg, state), + ClaudeEvent::ContentBlockStart(cb) => map_content_block_start(cb, state), + ClaudeEvent::ContentBlockDelta(cbd) => map_content_block_delta(cbd, state), + ClaudeEvent::ContentBlockStop(cbs) => map_content_block_stop(cbs, state), + ClaudeEvent::MessageDelta(md) => map_message_delta(md, state), + ClaudeEvent::MessageStop(_) => map_message_stop(state), + ClaudeEvent::Result(res) => map_result(res, state), + ClaudeEvent::Assistant(a) => map_assistant(a, state), + ClaudeEvent::Unknown => vec![], + } +} + +fn map_system( + sys: &super::types::SystemEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + + if let Some(ref model) = sys.model { + state.model = Some(model.clone()); + } + + // Emit codex/connected + out.push(json!({ + "method": "codex/connected", + "params": { + "workspaceId": state.workspace_id + } + })); + + // Emit thread/started + if !state.thread_started { + state.thread_started = true; + out.push(json!({ + "method": "thread/started", + "params": { + "threadId": state.thread_id, + "thread": { + "id": state.thread_id, + "name": "New conversation", + "status": "active", + "source": "appServer" + } + } + })); + } + + out +} + +fn map_message_start( + msg: &super::types::MessageStartEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + + if let Some(ref info) = msg.message { + if let Some(ref model) = info.model { + state.model = Some(model.clone()); + } + } + + // Emit turn/started if not yet done for this turn + if !state.turn_started { + state.turn_started = true; + out.push(json!({ + "method": "turn/started", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id + } + })); + } + + out +} + +fn map_content_block_start( + cb: &super::types::ContentBlockEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + let Some(ref block) = cb.content_block else { + return out; + }; + + match block { + ContentBlock::Text { .. } => { + let item_id = state.next_item(); + state.block_items.insert(cb.index, item_id.clone()); + out.push(json!({ + "method": "item/started", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "item": { + "id": item_id, + "type": "agentMessage", + "status": "in_progress" + } + } + })); + } + ContentBlock::Thinking { .. } => { + let item_id = state.next_item(); + state.block_items.insert(cb.index, item_id.clone()); + out.push(json!({ + "method": "item/started", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "item": { + "id": item_id, + "type": "reasoning", + "status": "in_progress" + } + } + })); + } + ContentBlock::ToolUse { id, name, input } => { + let item_id = state.next_item(); + state.block_items.insert(cb.index, item_id.clone()); + out.push(json!({ + "method": "item/started", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "item": { + "id": item_id, + "type": "commandExecution", + "status": "in_progress", + "toolUseId": id, + "toolName": name, + "input": input + } + } + })); + } + _ => {} + } + + out +} + +fn map_content_block_delta( + cbd: &super::types::ContentBlockDeltaEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + let Some(ref delta) = cbd.delta else { + return out; + }; + let item_id = match state.block_items.get(&cbd.index) { + Some(id) => id.clone(), + None => return out, + }; + + match delta { + ContentBlockDelta::TextDelta { text } => { + state.accumulated_text.push_str(text); + out.push(json!({ + "method": "item/agentMessage/delta", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "itemId": item_id, + "delta": text + } + })); + } + ContentBlockDelta::ThinkingDelta { thinking } => { + out.push(json!({ + "method": "item/reasoning/textDelta", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "itemId": item_id, + "delta": thinking + } + })); + } + ContentBlockDelta::InputJsonDelta { partial_json } => { + out.push(json!({ + "method": "item/commandExecution/outputDelta", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "itemId": item_id, + "delta": partial_json + } + })); + } + ContentBlockDelta::Other => {} + } + + out +} + +fn map_content_block_stop( + cbs: &super::types::ContentBlockStopEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + if let Some(item_id) = state.block_items.get(&cbs.index) { + out.push(json!({ + "method": "item/completed", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "itemId": item_id, + "status": "completed" + } + })); + } + out +} + +fn map_message_delta( + md: &super::types::MessageDeltaEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + if let Some(ref usage) = md.usage { + out.push(json!({ + "method": "thread/tokenUsage/updated", + "params": { + "threadId": state.thread_id, + "usage": { + "inputTokens": usage.input_tokens, + "outputTokens": usage.output_tokens, + "cacheCreationInputTokens": usage.cache_creation_input_tokens, + "cacheReadInputTokens": usage.cache_read_input_tokens, + } + } + })); + } + out +} + +fn map_message_stop(state: &mut BridgeState) -> Vec { + // Message stop doesn't directly map to a single event. + // Turn completion is handled by the result event. + let _ = state; + vec![] +} + +fn map_result( + res: &super::types::ResultEvent, + state: &mut BridgeState, +) -> Vec { + let mut out = Vec::new(); + + // Emit token usage if available + if let Some(ref usage) = res.usage { + out.push(json!({ + "method": "thread/tokenUsage/updated", + "params": { + "threadId": state.thread_id, + "usage": { + "inputTokens": usage.input_tokens, + "outputTokens": usage.output_tokens, + "cacheCreationInputTokens": usage.cache_creation_input_tokens, + "cacheReadInputTokens": usage.cache_read_input_tokens, + } + } + })); + } + + // Emit turn/completed + if state.turn_started { + out.push(json!({ + "method": "turn/completed", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "status": if res.is_error { "error" } else { "completed" } + } + })); + } + + // Auto-name the thread from first ~38 chars of accumulated text + if !state.accumulated_text.is_empty() { + let name: String = state.accumulated_text.chars().take(38).collect(); + let name = name.trim().to_string(); + if !name.is_empty() { + out.push(json!({ + "method": "thread/name/updated", + "params": { + "threadId": state.thread_id, + "name": name + } + })); + } + } + + // Prepare for next turn + state.new_turn(); + + out +} + +fn map_assistant( + a: &super::types::AssistantEvent, + state: &mut BridgeState, +) -> Vec { + // The top-level "assistant" event type is a fallback for simpler streaming + // modes. In full streaming mode, content_block events carry the data. + // Handle the "text" subtype as a simple message delta. + let mut out = Vec::new(); + if a.subtype.as_deref() == Some("text") { + if let Some(ref msg) = a.message { + if let Some(text) = msg.as_str() { + state.accumulated_text.push_str(text); + let item_id = state + .block_items + .values() + .next() + .cloned() + .unwrap_or_else(|| { + let id = state.next_item(); + state.block_items.insert(0, id.clone()); + id + }); + out.push(json!({ + "method": "item/agentMessage/delta", + "params": { + "threadId": state.thread_id, + "turnId": state.turn_id, + "itemId": item_id, + "delta": text + } + })); + } + } + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::claude_bridge::types::*; + + fn make_state() -> BridgeState { + BridgeState::new("ws_test".to_string(), "thread_test".to_string()) + } + + #[test] + fn system_event_emits_connected_and_thread_started() { + let mut state = make_state(); + let event = ClaudeEvent::System(SystemEvent { + subtype: None, + session_id: Some("sess_123".to_string()), + tools: None, + model: Some("claude-sonnet-4-20250514".to_string()), + extra: Default::default(), + }); + + let messages = map_event(&event, &mut state); + assert_eq!(messages.len(), 2); + + assert_eq!(messages[0]["method"], "codex/connected"); + assert_eq!(messages[0]["params"]["workspaceId"], "ws_test"); + + assert_eq!(messages[1]["method"], "thread/started"); + assert_eq!(messages[1]["params"]["threadId"], "thread_test"); + + assert!(state.thread_started); + assert_eq!(state.model.as_deref(), Some("claude-sonnet-4-20250514")); + } + + #[test] + fn system_event_only_emits_thread_started_once() { + let mut state = make_state(); + state.thread_started = true; + let event = ClaudeEvent::System(SystemEvent { + subtype: None, + session_id: None, + tools: None, + model: None, + extra: Default::default(), + }); + + let messages = map_event(&event, &mut state); + assert_eq!(messages.len(), 1); // only codex/connected + } + + #[test] + fn message_start_emits_turn_started() { + let mut state = make_state(); + let event = ClaudeEvent::MessageStart(MessageStartEvent { + message: Some(MessageInfo { + id: Some("msg_123".to_string()), + role: Some("assistant".to_string()), + model: Some("claude-sonnet-4-20250514".to_string()), + usage: None, + }), + }); + + let messages = map_event(&event, &mut state); + assert_eq!(messages.len(), 1); + assert_eq!(messages[0]["method"], "turn/started"); + assert!(state.turn_started); + } + + #[test] + fn text_content_block_lifecycle() { + let mut state = make_state(); + state.thread_started = true; + state.turn_started = true; + + // content_block_start (text) + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::Text { + text: String::new(), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/started"); + assert_eq!(msgs[0]["params"]["item"]["type"], "agentMessage"); + + // content_block_delta (text) + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::TextDelta { + text: "Hello world".to_string(), + }), + }); + let msgs = map_event(&delta, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/agentMessage/delta"); + assert_eq!(msgs[0]["params"]["delta"], "Hello world"); + + // content_block_stop + let stop = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 }); + let msgs = map_event(&stop, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/completed"); + } + + #[test] + fn thinking_content_block_maps_to_reasoning() { + let mut state = make_state(); + state.turn_started = true; + + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::Thinking { + thinking: String::new(), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs[0]["params"]["item"]["type"], "reasoning"); + + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::ThinkingDelta { + thinking: "Let me think...".to_string(), + }), + }); + let msgs = map_event(&delta, &mut state); + assert_eq!(msgs[0]["method"], "item/reasoning/textDelta"); + assert_eq!(msgs[0]["params"]["delta"], "Let me think..."); + } + + #[test] + fn tool_use_content_block_maps_to_command_execution() { + let mut state = make_state(); + state.turn_started = true; + + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "tool_123".to_string(), + name: "bash".to_string(), + input: json!({}), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs[0]["params"]["item"]["type"], "commandExecution"); + assert_eq!(msgs[0]["params"]["item"]["toolName"], "bash"); + + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::InputJsonDelta { + partial_json: "{\"command\":\"ls\"}".to_string(), + }), + }); + let msgs = map_event(&delta, &mut state); + assert_eq!(msgs[0]["method"], "item/commandExecution/outputDelta"); + } + + #[test] + fn result_event_emits_turn_completed_and_thread_name() { + let mut state = make_state(); + state.turn_started = true; + state.accumulated_text = "Here is the answer to your question".to_string(); + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, + result: None, + error: None, + duration_ms: Some(1500), + duration_api_ms: Some(1200), + num_turns: Some(1), + is_error: false, + session_id: None, + cost_usd: Some(0.01), + usage: Some(UsageInfo { + input_tokens: 100, + output_tokens: 50, + cache_creation_input_tokens: None, + cache_read_input_tokens: None, + }), + extra: Default::default(), + }); + + let msgs = map_event(&event, &mut state); + + // Should have: tokenUsage, turn/completed, thread/name/updated + let methods: Vec<&str> = msgs + .iter() + .map(|m| m["method"].as_str().unwrap()) + .collect(); + assert!(methods.contains(&"thread/tokenUsage/updated")); + assert!(methods.contains(&"turn/completed")); + assert!(methods.contains(&"thread/name/updated")); + + // Turn should be reset + assert!(!state.turn_started); + } + + #[test] + fn result_error_emits_error_status() { + let mut state = make_state(); + state.turn_started = true; + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, + result: None, + error: Some("API error".to_string()), + duration_ms: None, + duration_api_ms: None, + num_turns: None, + is_error: true, + session_id: None, + cost_usd: None, + usage: None, + extra: Default::default(), + }); + + let msgs = map_event(&event, &mut state); + let turn_completed = msgs + .iter() + .find(|m| m["method"] == "turn/completed") + .unwrap(); + assert_eq!(turn_completed["params"]["status"], "error"); + } + + #[test] + fn unknown_event_produces_no_output() { + let mut state = make_state(); + let msgs = map_event(&ClaudeEvent::Unknown, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn message_delta_with_usage_emits_token_update() { + let mut state = make_state(); + let event = ClaudeEvent::MessageDelta(MessageDeltaEvent { + delta: None, + usage: Some(UsageInfo { + input_tokens: 200, + output_tokens: 100, + cache_creation_input_tokens: Some(50), + cache_read_input_tokens: Some(30), + }), + }); + + let msgs = map_event(&event, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "thread/tokenUsage/updated"); + assert_eq!(msgs[0]["params"]["usage"]["inputTokens"], 200); + } +} diff --git a/src-tauri/src/claude_bridge/mod.rs b/src-tauri/src/claude_bridge/mod.rs new file mode 100644 index 000000000..df4e7cb6a --- /dev/null +++ b/src-tauri/src/claude_bridge/mod.rs @@ -0,0 +1,3 @@ +pub(crate) mod event_mapper; +pub(crate) mod process; +pub(crate) mod types; diff --git a/src-tauri/src/claude_bridge/process.rs b/src-tauri/src/claude_bridge/process.rs new file mode 100644 index 000000000..affa42a2b --- /dev/null +++ b/src-tauri/src/claude_bridge/process.rs @@ -0,0 +1,500 @@ +use serde_json::{json, Value}; +use std::collections::{HashMap, HashSet}; +use std::sync::atomic::AtomicU64; +use std::sync::Arc; + +use tokio::io::{AsyncBufReadExt, BufReader}; +use tokio::process::Command; +use tokio::sync::{mpsc, oneshot, Mutex}; + +use crate::backend::app_server::{InterceptAction, WorkspaceSession}; +use crate::backend::events::{AppServerEvent, EventSink}; +use crate::types::WorkspaceEntry; + +use super::event_mapper; +use super::types::BridgeState; + +/// Check that the `claude` CLI binary is available. +pub(crate) async fn check_claude_installation() -> Result { + let result = Command::new("claude") + .arg("--version") + .output() + .await + .map_err(|e| format!("Claude CLI not found in PATH: {e}"))?; + + if !result.status.success() { + return Err("Claude CLI --version returned non-zero exit code".to_string()); + } + + let version = String::from_utf8_lossy(&result.stdout).trim().to_string(); + Ok(version) +} + +/// Spawn a Claude CLI session that presents the same `WorkspaceSession` +/// interface as the Codex backend. The bridge translates between the +/// Codex JSON-RPC protocol and Claude CLI's stream-json format. +pub(crate) async fn spawn_claude_session( + entry: WorkspaceEntry, + _client_version: String, + event_sink: E, +) -> Result, String> { + let _ = check_claude_installation().await?; + + let thread_id = format!("thread_{}", uuid::Uuid::new_v4()); + + let mut command = Command::new("claude"); + command.args(["chat", "--output-format", "stream-json", "--verbose"]); + command.current_dir(&entry.path); + command.stdin(std::process::Stdio::piped()); + command.stdout(std::process::Stdio::piped()); + command.stderr(std::process::Stdio::piped()); + + let mut child = command + .spawn() + .map_err(|e| format!("Failed to spawn Claude CLI: {e}"))?; + + let stdin = child.stdin.take().ok_or("missing stdin")?; + let stdout = child.stdout.take().ok_or("missing stdout")?; + let stderr = child.stderr.take().ok_or("missing stderr")?; + + let workspace_id = entry.id.clone(); + let workspace_path = entry.path.clone(); + + // Build the request interceptor for Claude CLI protocol translation + let interceptor_thread_id = thread_id.clone(); + let interceptor_workspace_id = workspace_id.clone(); + let interceptor: Arc InterceptAction + Send + Sync> = + Arc::new(move |value: Value| { + build_claude_intercept_action( + &value, + &interceptor_thread_id, + &interceptor_workspace_id, + ) + }); + + let session = Arc::new(WorkspaceSession { + codex_args: None, + child: Mutex::new(child), + stdin: Mutex::new(stdin), + pending: Mutex::new(HashMap::new()), + request_context: Mutex::new(HashMap::new()), + thread_workspace: Mutex::new(HashMap::new()), + hidden_thread_ids: Mutex::new(HashSet::new()), + next_id: AtomicU64::new(1), + background_thread_callbacks: Mutex::new(HashMap::new()), + owner_workspace_id: workspace_id.clone(), + workspace_ids: Mutex::new(HashSet::from([workspace_id.clone()])), + workspace_roots: Mutex::new(HashMap::from([( + workspace_id.clone(), + workspace_path, + )])), + request_interceptor: Some(interceptor), + }); + + // Spawn Claude stdout reader with event translation + let event_sink_stdout = event_sink.clone(); + let ws_id_stdout = workspace_id.clone(); + let stdout_thread_id = thread_id.clone(); + tokio::spawn(async move { + let mut bridge_state = BridgeState::new(ws_id_stdout.clone(), stdout_thread_id); + let mut lines = BufReader::new(stdout).lines(); + while let Ok(Some(line)) = lines.next_line().await { + if line.trim().is_empty() { + continue; + } + + let claude_event: super::types::ClaudeEvent = match serde_json::from_str(&line) { + Ok(e) => e, + Err(err) => { + let payload = AppServerEvent { + workspace_id: ws_id_stdout.clone(), + message: json!({ + "method": "codex/parseError", + "params": { "error": err.to_string(), "raw": line }, + }), + }; + event_sink_stdout.emit_app_server_event(payload); + continue; + } + }; + + let codex_messages = event_mapper::map_event(&claude_event, &mut bridge_state); + for message in codex_messages { + let payload = AppServerEvent { + workspace_id: ws_id_stdout.clone(), + message, + }; + event_sink_stdout.emit_app_server_event(payload); + } + } + }); + + // Spawn Claude stderr reader + let event_sink_stderr = event_sink.clone(); + let ws_id_stderr = workspace_id.clone(); + tokio::spawn(async move { + let mut lines = BufReader::new(stderr).lines(); + while let Ok(Some(line)) = lines.next_line().await { + if line.trim().is_empty() { + continue; + } + let payload = AppServerEvent { + workspace_id: ws_id_stderr.clone(), + message: json!({ + "method": "codex/stderr", + "params": { "message": line }, + }), + }; + event_sink_stderr.emit_app_server_event(payload); + } + }); + + // Emit codex/connected immediately + let payload = AppServerEvent { + workspace_id: workspace_id.clone(), + message: json!({ + "method": "codex/connected", + "params": { "workspaceId": workspace_id } + }), + }; + event_sink.emit_app_server_event(payload); + + Ok(session) +} + +/// Determine how to handle a JSON-RPC message destined for Claude CLI. +fn build_claude_intercept_action( + value: &Value, + thread_id: &str, + _workspace_id: &str, +) -> InterceptAction { + let method = value + .get("method") + .and_then(|v| v.as_str()) + .unwrap_or(""); + let id = value.get("id").cloned(); + let params = value.get("params").cloned().unwrap_or(Value::Null); + + match method { + "initialize" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { + "capabilities": { "experimentalApi": true }, + "serverInfo": { + "name": "claude-bridge", + "version": "1.0.0" + } + } + })) + } else { + InterceptAction::Drop + } + } + + "initialized" => InterceptAction::Drop, + + "turn/start" => { + let text = extract_user_text(¶ms); + if text.is_empty() { + if let Some(id) = id { + return InterceptAction::Respond(json!({ + "id": id, + "error": { "message": "Empty user message" } + })); + } + return InterceptAction::Drop; + } + InterceptAction::Forward(text) + } + + "turn/steer" => { + let text = extract_user_text(¶ms); + if text.is_empty() { + if let Some(id) = id { + return InterceptAction::Respond(json!({ + "id": id, + "error": { "message": "Empty steer message" } + })); + } + return InterceptAction::Drop; + } + InterceptAction::Forward(text) + } + + "thread/start" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { + "threadId": thread_id, + "thread": { + "id": thread_id, + "name": "New conversation", + "status": "active", + "source": "appServer" + } + } + })) + } else { + InterceptAction::Drop + } + } + + "thread/resume" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { + "threadId": thread_id, + "thread": { + "id": thread_id, + "status": "active" + } + } + })) + } else { + InterceptAction::Drop + } + } + + "thread/list" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { + "data": [{ + "id": thread_id, + "name": "Claude CLI session", + "status": "active", + "source": "appServer" + }] + } + })) + } else { + InterceptAction::Drop + } + } + + "model/list" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { + "data": [{ + "id": "claude-sonnet-4-20250514", + "name": "Claude Sonnet 4", + "isDefault": true + }] + } + })) + } else { + InterceptAction::Drop + } + } + + "turn/interrupt" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { "ok": true } + })) + } else { + InterceptAction::Drop + } + } + + "thread/fork" | "thread/archive" | "thread/compact/start" + | "thread/name/set" | "review/start" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { "ok": true } + })) + } else { + InterceptAction::Drop + } + } + + "skills/list" | "app/list" | "mcpServerStatus/list" + | "experimentalFeature/list" | "collaborationMode/list" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": { "data": [] } + })) + } else { + InterceptAction::Drop + } + } + + "account/read" | "account/rateLimits/read" | "account/login/start" + | "account/login/cancel" => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "result": {} + })) + } else { + InterceptAction::Drop + } + } + + _ => { + if let Some(id) = id { + InterceptAction::Respond(json!({ + "id": id, + "error": { + "message": format!("Method not supported in Claude CLI mode: {method}") + } + })) + } else { + InterceptAction::Drop + } + } + } +} + +/// Extract user text from turn/start params. +fn extract_user_text(params: &Value) -> String { + if let Some(input) = params.get("input").and_then(|v| v.as_array()) { + let texts: Vec<&str> = input + .iter() + .filter_map(|item| { + if item.get("type").and_then(|t| t.as_str()) == Some("text") { + item.get("text").and_then(|t| t.as_str()) + } else { + None + } + }) + .collect(); + if !texts.is_empty() { + return texts.join("\n"); + } + } + + if let Some(text) = params.get("text").and_then(|v| v.as_str()) { + return text.to_string(); + } + + String::new() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn extract_user_text_from_input_items() { + let params = json!({ + "input": [ + { "type": "text", "text": "Hello" }, + { "type": "image", "url": "data:..." } + ] + }); + assert_eq!(extract_user_text(¶ms), "Hello"); + } + + #[test] + fn extract_user_text_from_text_field() { + let params = json!({ "text": "Hello world" }); + assert_eq!(extract_user_text(¶ms), "Hello world"); + } + + #[test] + fn extract_user_text_empty_when_missing() { + let params = json!({}); + assert_eq!(extract_user_text(¶ms), ""); + } + + #[test] + fn intercept_initialize_responds_immediately() { + let action = + build_claude_intercept_action(&json!({"id": 1, "method": "initialize"}), "t1", "w1"); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 1); + assert!(v["result"]["serverInfo"]["name"].as_str().is_some()); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_turn_start_forwards_text() { + let action = build_claude_intercept_action( + &json!({ + "id": 2, + "method": "turn/start", + "params": { + "input": [{ "type": "text", "text": "What is Rust?" }] + } + }), + "t1", + "w1", + ); + match action { + InterceptAction::Forward(text) => assert_eq!(text, "What is Rust?"), + _ => panic!("Expected Forward"), + } + } + + #[test] + fn intercept_thread_list_responds_with_mock() { + let action = build_claude_intercept_action( + &json!({"id": 3, "method": "thread/list"}), + "thread_abc", + "ws_1", + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 3); + let data = v["result"]["data"].as_array().unwrap(); + assert_eq!(data[0]["id"], "thread_abc"); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_unknown_method_returns_error() { + let action = build_claude_intercept_action( + &json!({"id": 4, "method": "some/unknown"}), + "t1", + "w1", + ); + match action { + InterceptAction::Respond(v) => { + assert!(v["error"]["message"].as_str().is_some()); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_notification_drops_initialized() { + let action = + build_claude_intercept_action(&json!({"method": "initialized"}), "t1", "w1"); + assert!(matches!(action, InterceptAction::Drop)); + } + + #[test] + fn intercept_empty_turn_start_returns_error() { + let action = build_claude_intercept_action( + &json!({ + "id": 5, + "method": "turn/start", + "params": { "input": [] } + }), + "t1", + "w1", + ); + match action { + InterceptAction::Respond(v) => { + assert!(v["error"].is_object()); + } + _ => panic!("Expected Respond with error"), + } + } +} diff --git a/src-tauri/src/claude_bridge/types.rs b/src-tauri/src/claude_bridge/types.rs new file mode 100644 index 000000000..3f4f5ac01 --- /dev/null +++ b/src-tauri/src/claude_bridge/types.rs @@ -0,0 +1,261 @@ +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +/// Represents a single event from Claude CLI's `--output-format stream-json` output. +/// Each line of stdout is one JSON object with a `type` field. +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "type")] +pub(crate) enum ClaudeEvent { + /// System initialization event, emitted once at startup. + #[serde(rename = "system")] + System(SystemEvent), + + /// Assistant text streaming delta. + #[serde(rename = "assistant")] + Assistant(AssistantEvent), + + /// Content block start/delta/stop within a message. + #[serde(rename = "content_block_start")] + ContentBlockStart(ContentBlockEvent), + #[serde(rename = "content_block_delta")] + ContentBlockDelta(ContentBlockDeltaEvent), + #[serde(rename = "content_block_stop")] + ContentBlockStop(ContentBlockStopEvent), + + /// Message start/delta/stop events. + #[serde(rename = "message_start")] + MessageStart(MessageStartEvent), + #[serde(rename = "message_delta")] + MessageDelta(MessageDeltaEvent), + #[serde(rename = "message_stop")] + MessageStop(MessageStopEvent), + + /// Result event emitted when a turn completes. + #[serde(rename = "result")] + Result(ResultEvent), + + /// Unknown/unhandled event type - captured as raw JSON. + #[serde(other)] + Unknown, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct SystemEvent { + #[serde(default)] + pub(crate) subtype: Option, + #[serde(default)] + pub(crate) session_id: Option, + #[serde(default)] + pub(crate) tools: Option>, + #[serde(default)] + pub(crate) model: Option, + /// Catch-all for extra fields. + #[serde(flatten)] + pub(crate) extra: std::collections::HashMap, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct AssistantEvent { + #[serde(default)] + pub(crate) subtype: Option, + #[serde(default)] + pub(crate) message: Option, + #[serde(default)] + pub(crate) content_block: Option, + #[serde(flatten)] + pub(crate) extra: std::collections::HashMap, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct ContentBlockEvent { + #[serde(default)] + pub(crate) index: u64, + #[serde(default)] + pub(crate) content_block: Option, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct ContentBlockDeltaEvent { + #[serde(default)] + pub(crate) index: u64, + #[serde(default)] + pub(crate) delta: Option, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct ContentBlockStopEvent { + #[serde(default)] + pub(crate) index: u64, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "type")] +pub(crate) enum ContentBlock { + #[serde(rename = "text")] + Text { + #[serde(default)] + text: String, + }, + #[serde(rename = "thinking")] + Thinking { + #[serde(default)] + thinking: String, + }, + #[serde(rename = "tool_use")] + ToolUse { + id: String, + name: String, + #[serde(default)] + input: Value, + }, + #[serde(rename = "tool_result")] + ToolResult { + #[serde(default)] + tool_use_id: Option, + #[serde(default)] + content: Option, + }, + #[serde(other)] + Other, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "type")] +pub(crate) enum ContentBlockDelta { + #[serde(rename = "text_delta")] + TextDelta { + #[serde(default)] + text: String, + }, + #[serde(rename = "thinking_delta")] + ThinkingDelta { + #[serde(default)] + thinking: String, + }, + #[serde(rename = "input_json_delta")] + InputJsonDelta { + #[serde(default)] + partial_json: String, + }, + #[serde(other)] + Other, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct MessageStartEvent { + #[serde(default)] + pub(crate) message: Option, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct MessageInfo { + #[serde(default)] + pub(crate) id: Option, + #[serde(default)] + pub(crate) role: Option, + #[serde(default)] + pub(crate) model: Option, + #[serde(default)] + pub(crate) usage: Option, +} + +#[derive(Debug, Clone, Deserialize, Serialize)] +pub(crate) struct UsageInfo { + #[serde(default)] + pub(crate) input_tokens: u64, + #[serde(default)] + pub(crate) output_tokens: u64, + #[serde(default)] + pub(crate) cache_creation_input_tokens: Option, + #[serde(default)] + pub(crate) cache_read_input_tokens: Option, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct MessageDeltaEvent { + #[serde(default)] + pub(crate) delta: Option, + #[serde(default)] + pub(crate) usage: Option, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct MessageStopEvent { + #[serde(flatten)] + pub(crate) extra: std::collections::HashMap, +} + +#[derive(Debug, Clone, Deserialize)] +pub(crate) struct ResultEvent { + #[serde(default)] + pub(crate) subtype: Option, + #[serde(default)] + pub(crate) result: Option, + #[serde(default)] + pub(crate) error: Option, + #[serde(default)] + pub(crate) duration_ms: Option, + #[serde(default)] + pub(crate) duration_api_ms: Option, + #[serde(default)] + pub(crate) num_turns: Option, + #[serde(default)] + pub(crate) is_error: bool, + #[serde(default)] + pub(crate) session_id: Option, + #[serde(default)] + pub(crate) cost_usd: Option, + #[serde(default)] + pub(crate) usage: Option, + #[serde(flatten)] + pub(crate) extra: std::collections::HashMap, +} + +/// State tracked across the lifetime of a Claude CLI session to correlate +/// events and generate consistent Codex-compatible IDs. +pub(crate) struct BridgeState { + pub(crate) thread_id: String, + pub(crate) turn_id: String, + pub(crate) workspace_id: String, + /// Counter for generating unique item IDs. + pub(crate) next_item_id: u64, + /// Maps content block index to the item ID assigned for that block. + pub(crate) block_items: std::collections::HashMap, + /// Accumulated text from assistant text blocks (for thread naming). + pub(crate) accumulated_text: String, + /// Whether `thread/started` has been emitted. + pub(crate) thread_started: bool, + /// Whether `turn/started` has been emitted for the current turn. + pub(crate) turn_started: bool, + /// Model ID reported by Claude. + pub(crate) model: Option, +} + +impl BridgeState { + pub(crate) fn new(workspace_id: String, thread_id: String) -> Self { + let turn_id = format!("turn_{}", uuid::Uuid::new_v4()); + Self { + thread_id, + turn_id, + workspace_id, + next_item_id: 1, + block_items: std::collections::HashMap::new(), + accumulated_text: String::new(), + thread_started: false, + turn_started: false, + model: None, + } + } + + pub(crate) fn next_item(&mut self) -> String { + let id = format!("item_{}", self.next_item_id); + self.next_item_id += 1; + id + } + + pub(crate) fn new_turn(&mut self) { + self.turn_id = format!("turn_{}", uuid::Uuid::new_v4()); + self.turn_started = false; + self.block_items.clear(); + } +} diff --git a/src-tauri/src/codex/mod.rs b/src-tauri/src/codex/mod.rs index 8bbb7757c..0f87b7d45 100644 --- a/src-tauri/src/codex/mod.rs +++ b/src-tauri/src/codex/mod.rs @@ -2,7 +2,7 @@ use serde_json::{json, Map, Value}; use std::path::PathBuf; use std::sync::Arc; -use tauri::{AppHandle, Emitter, State}; +use tauri::{AppHandle, Emitter, Manager, State}; pub(crate) mod args; pub(crate) mod config; @@ -11,12 +11,13 @@ pub(crate) mod home; use crate::backend::app_server::spawn_workspace_session as spawn_workspace_session_inner; pub(crate) use crate::backend::app_server::WorkspaceSession; use crate::backend::events::AppServerEvent; +use crate::claude_bridge::process::spawn_claude_session; use crate::event_sink::TauriEventSink; use crate::remote_backend; use crate::shared::agents_config_core; use crate::shared::codex_core; use crate::state::AppState; -use crate::types::WorkspaceEntry; +use crate::types::{BackendMode, WorkspaceEntry}; fn emit_thread_live_event(app: &AppHandle, workspace_id: &str, method: &str, params: Value) { let _ = app.emit( @@ -39,7 +40,19 @@ pub(crate) async fn spawn_workspace_session( codex_home: Option, ) -> Result, String> { let client_version = app_handle.package_info().version.to_string(); - let event_sink = TauriEventSink::new(app_handle); + let event_sink = TauriEventSink::new(app_handle.clone()); + + // Check if Claude CLI mode is enabled in settings + let use_claude = { + let state = app_handle.state::(); + let settings = state.app_settings.lock().await; + settings.backend_mode == BackendMode::Claude + }; + + if use_claude { + return spawn_claude_session(entry, client_version, event_sink).await; + } + spawn_workspace_session_inner( entry, default_codex_bin, diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 318aa5f94..693613ba1 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -7,6 +7,7 @@ use tauri::RunEvent; use tauri::WindowEvent; mod backend; +pub(crate) mod claude_bridge; mod codex; mod daemon_binary; mod dictation; diff --git a/src-tauri/src/shared/workspaces_core/connect.rs b/src-tauri/src/shared/workspaces_core/connect.rs index bf255a138..07ecb9211 100644 --- a/src-tauri/src/shared/workspaces_core/connect.rs +++ b/src-tauri/src/shared/workspaces_core/connect.rs @@ -180,6 +180,7 @@ mod tests { owner_workspace_id: "test-owner".to_string(), workspace_ids: Mutex::new(HashSet::from(["test-owner".to_string()])), workspace_roots: Mutex::new(HashMap::new()), + request_interceptor: None, }) } diff --git a/src-tauri/src/shared/workspaces_core/runtime_codex_args.rs b/src-tauri/src/shared/workspaces_core/runtime_codex_args.rs index 9801e6c5e..d62ef4d27 100644 --- a/src-tauri/src/shared/workspaces_core/runtime_codex_args.rs +++ b/src-tauri/src/shared/workspaces_core/runtime_codex_args.rs @@ -180,6 +180,7 @@ mod tests { owner_workspace_id: "test-owner".to_string(), workspace_ids: Mutex::new(HashSet::from(["test-owner".to_string()])), workspace_roots: Mutex::new(HashMap::new()), + request_interceptor: None, } } diff --git a/src-tauri/src/types.rs b/src-tauri/src/types.rs index cbb8afbaa..107385193 100644 --- a/src-tauri/src/types.rs +++ b/src-tauri/src/types.rs @@ -641,11 +641,13 @@ pub(crate) struct AppSettings { pub(crate) selected_open_app_id: String, } -#[derive(Debug, Serialize, Deserialize, Clone)] +#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)] #[serde(rename_all = "lowercase")] pub(crate) enum BackendMode { Local, Remote, + /// Use Claude CLI as the backend instead of Codex. + Claude, } impl Default for BackendMode { From 943a5c83797f529dfe76ac3976f924f0216ff99b Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 06:30:31 +0000 Subject: [PATCH 04/16] feat: Phase 2 - Tool Execution & Item Management Add item_tracker module for rich tool classification and lifecycle tracking: - Classify tool names into categories (CommandExecution, FileChange, FileRead) - Accumulate streaming input JSON to extract display fields (command, path) - Build enriched item/started and item/completed events with frontend-compatible shapes - Map tool results to category-appropriate output deltas - Support fileChange items with changes array (path, kind, diff) - Support commandExecution items with command and aggregatedOutput fields 28 new tests (403 total), 0 failures, no regressions. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src-tauri/src/claude_bridge/event_mapper.rs | 340 +++++++++++++- src-tauri/src/claude_bridge/item_tracker.rs | 465 ++++++++++++++++++++ src-tauri/src/claude_bridge/mod.rs | 1 + src-tauri/src/claude_bridge/types.rs | 10 + 4 files changed, 802 insertions(+), 14 deletions(-) create mode 100644 src-tauri/src/claude_bridge/item_tracker.rs diff --git a/src-tauri/src/claude_bridge/event_mapper.rs b/src-tauri/src/claude_bridge/event_mapper.rs index f4a89ac15..150fd5d40 100644 --- a/src-tauri/src/claude_bridge/event_mapper.rs +++ b/src-tauri/src/claude_bridge/event_mapper.rs @@ -1,5 +1,6 @@ use serde_json::{json, Value}; +use super::item_tracker::{self, ItemInfo}; use super::types::{ BridgeState, ClaudeEvent, ContentBlock, ContentBlockDelta, }; @@ -130,24 +131,50 @@ fn map_content_block_start( } })); } - ContentBlock::ToolUse { id, name, input } => { + ContentBlock::ToolUse { id, name, .. } => { let item_id = state.next_item(); state.block_items.insert(cb.index, item_id.clone()); - out.push(json!({ - "method": "item/started", - "params": { - "threadId": state.thread_id, - "turnId": state.turn_id, - "item": { - "id": item_id, - "type": "commandExecution", - "status": "in_progress", - "toolUseId": id, - "toolName": name, - "input": input + + let category = item_tracker::classify_tool(name); + let info = ItemInfo { + item_id: item_id.clone(), + tool_use_id: id.clone(), + tool_name: name.clone(), + category, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }; + + let event = item_tracker::build_item_started( + &info, + &state.thread_id, + &state.turn_id, + ); + + state.block_tool_use_ids.insert(cb.index, id.clone()); + state.tool_items.insert(id.clone(), info); + + out.push(event); + } + ContentBlock::ToolResult { + tool_use_id, + content, + } => { + // Map tool result content to output delta for the original item + if let Some(ref tuid) = tool_use_id { + let result_text = extract_tool_result_text(content.as_ref()); + if !result_text.is_empty() { + if let Some(info) = state.tool_items.get_mut(tuid) { + info.aggregated_output.push_str(&result_text); + out.push(item_tracker::build_output_delta( + info, + &state.thread_id, + &state.turn_id, + &result_text, + )); } } - })); + } } _ => {} } @@ -155,6 +182,32 @@ fn map_content_block_start( out } +/// Extract text from a tool result content value. +fn extract_tool_result_text(content: Option<&Value>) -> String { + let Some(content) = content else { + return String::new(); + }; + // Content can be a string directly + if let Some(s) = content.as_str() { + return s.to_string(); + } + // Or an array of content blocks + if let Some(arr) = content.as_array() { + let texts: Vec<&str> = arr + .iter() + .filter_map(|item| { + if item.get("type").and_then(|t| t.as_str()) == Some("text") { + item.get("text").and_then(|t| t.as_str()) + } else { + None + } + }) + .collect(); + return texts.join("\n"); + } + String::new() +} + fn map_content_block_delta( cbd: &super::types::ContentBlockDeltaEvent, state: &mut BridgeState, @@ -193,6 +246,20 @@ fn map_content_block_delta( })); } ContentBlockDelta::InputJsonDelta { partial_json } => { + // Accumulate input JSON in the item tracker + if let Some(tool_use_id) = state.block_tool_use_ids.get(&cbd.index) { + if let Some(info) = state.tool_items.get_mut(tool_use_id) { + info.accumulated_input_json.push_str(partial_json); + out.push(item_tracker::build_output_delta( + info, + &state.thread_id, + &state.turn_id, + partial_json, + )); + return out; + } + } + // Fallback if no tool tracking info found out.push(json!({ "method": "item/commandExecution/outputDelta", "params": { @@ -214,6 +281,20 @@ fn map_content_block_stop( state: &mut BridgeState, ) -> Vec { let mut out = Vec::new(); + + // Check if this is a tool block — emit enriched item/completed + if let Some(tool_use_id) = state.block_tool_use_ids.get(&cbs.index) { + if let Some(info) = state.tool_items.get(tool_use_id) { + out.push(item_tracker::build_item_completed( + info, + &state.thread_id, + &state.turn_id, + )); + return out; + } + } + + // Non-tool block: emit simple item/completed if let Some(item_id) = state.block_items.get(&cbs.index) { out.push(json!({ "method": "item/completed", @@ -597,4 +678,235 @@ mod tests { assert_eq!(msgs[0]["method"], "thread/tokenUsage/updated"); assert_eq!(msgs[0]["params"]["usage"]["inputTokens"], 200); } + + // ── Phase 2: Tool Execution & Item Management ──────────────── + + #[test] + fn bash_tool_lifecycle_produces_command_execution() { + let mut state = make_state(); + state.turn_started = true; + + // 1. content_block_start with tool_use (bash) + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_abc".to_string(), + name: "bash".to_string(), + input: json!({}), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/started"); + assert_eq!(msgs[0]["params"]["item"]["type"], "commandExecution"); + assert_eq!(msgs[0]["params"]["item"]["toolName"], "bash"); + assert_eq!(msgs[0]["params"]["item"]["command"], ""); + + let item_id = msgs[0]["params"]["item"]["id"].as_str().unwrap().to_string(); + + // 2. content_block_delta with input_json_delta + let delta1 = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::InputJsonDelta { + partial_json: r#"{"comma"#.to_string(), + }), + }); + let msgs = map_event(&delta1, &mut state); + assert_eq!(msgs[0]["method"], "item/commandExecution/outputDelta"); + + let delta2 = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::InputJsonDelta { + partial_json: r#"nd": "ls -la"}"#.to_string(), + }), + }); + let msgs = map_event(&delta2, &mut state); + assert_eq!(msgs[0]["method"], "item/commandExecution/outputDelta"); + + // 3. content_block_stop → enriched item/completed with command + let stop = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 }); + let msgs = map_event(&stop, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/completed"); + assert_eq!(msgs[0]["params"]["itemId"], item_id); + assert_eq!(msgs[0]["params"]["status"], "completed"); + assert_eq!(msgs[0]["params"]["command"], "ls -la"); + } + + #[test] + fn write_file_tool_produces_file_change() { + let mut state = make_state(); + state.turn_started = true; + + // Start + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_xyz".to_string(), + name: "write_file".to_string(), + input: json!({}), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs[0]["params"]["item"]["type"], "fileChange"); + assert_eq!(msgs[0]["params"]["item"]["toolName"], "write_file"); + + // Input delta + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::InputJsonDelta { + partial_json: r#"{"path": "src/main.rs", "content": "fn main() {}"}"#.to_string(), + }), + }); + let msgs = map_event(&delta, &mut state); + assert_eq!(msgs[0]["method"], "item/fileChange/outputDelta"); + + // Stop → enriched with changes array + let stop = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 }); + let msgs = map_event(&stop, &mut state); + assert_eq!(msgs[0]["method"], "item/completed"); + let changes = msgs[0]["params"]["changes"].as_array().unwrap(); + assert_eq!(changes.len(), 1); + assert_eq!(changes[0]["path"], "src/main.rs"); + assert_eq!(changes[0]["kind"], "add"); + } + + #[test] + fn edit_file_tool_produces_file_change_modify() { + let mut state = make_state(); + state.turn_started = true; + + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_edit".to_string(), + name: "edit_file".to_string(), + input: json!({}), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs[0]["params"]["item"]["type"], "fileChange"); + + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::InputJsonDelta { + partial_json: r#"{"path": "lib.rs"}"#.to_string(), + }), + }); + map_event(&delta, &mut state); + + let stop = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 }); + let msgs = map_event(&stop, &mut state); + let changes = msgs[0]["params"]["changes"].as_array().unwrap(); + assert_eq!(changes[0]["kind"], "modify"); + } + + #[test] + fn unknown_tool_defaults_to_command_execution() { + let mut state = make_state(); + state.turn_started = true; + + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_custom".to_string(), + name: "my_custom_tool".to_string(), + input: json!({}), + }), + }); + let msgs = map_event(&start, &mut state); + assert_eq!(msgs[0]["params"]["item"]["type"], "commandExecution"); + } + + #[test] + fn tool_result_content_maps_to_output_delta() { + let mut state = make_state(); + state.turn_started = true; + + // Start a bash tool + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_res".to_string(), + name: "bash".to_string(), + input: json!({}), + }), + }); + map_event(&start, &mut state); + + // Stop the tool block + let stop = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 0 }); + map_event(&stop, &mut state); + + // Tool result arrives as a new content block + let result = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 1, + content_block: Some(ContentBlock::ToolResult { + tool_use_id: Some("toolu_res".to_string()), + content: Some(json!("file1.txt\nfile2.txt\n")), + }), + }); + let msgs = map_event(&result, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/commandExecution/outputDelta"); + assert_eq!(msgs[0]["params"]["delta"], "file1.txt\nfile2.txt\n"); + + // Verify aggregated_output was stored + let info = state.tool_items.get("toolu_res").unwrap(); + assert_eq!(info.aggregated_output, "file1.txt\nfile2.txt\n"); + } + + #[test] + fn tool_result_array_content_extracts_text() { + let mut state = make_state(); + state.turn_started = true; + + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_arr".to_string(), + name: "bash".to_string(), + input: json!({}), + }), + }); + map_event(&start, &mut state); + + let result = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 1, + content_block: Some(ContentBlock::ToolResult { + tool_use_id: Some("toolu_arr".to_string()), + content: Some(json!([ + {"type": "text", "text": "line1"}, + {"type": "image", "url": "data:..."}, + {"type": "text", "text": "line2"} + ])), + }), + }); + let msgs = map_event(&result, &mut state); + assert_eq!(msgs[0]["params"]["delta"], "line1\nline2"); + } + + #[test] + fn new_turn_clears_tool_tracking_state() { + let mut state = make_state(); + state.turn_started = true; + + // Start a tool + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::ToolUse { + id: "toolu_clear".to_string(), + name: "bash".to_string(), + input: json!({}), + }), + }); + map_event(&start, &mut state); + assert!(!state.tool_items.is_empty()); + assert!(!state.block_tool_use_ids.is_empty()); + + // New turn should clear + state.new_turn(); + assert!(state.tool_items.is_empty()); + assert!(state.block_tool_use_ids.is_empty()); + } } diff --git a/src-tauri/src/claude_bridge/item_tracker.rs b/src-tauri/src/claude_bridge/item_tracker.rs new file mode 100644 index 000000000..e695714c2 --- /dev/null +++ b/src-tauri/src/claude_bridge/item_tracker.rs @@ -0,0 +1,465 @@ +use serde_json::{json, Value}; + +/// Classification of Claude CLI tool names into Codex item types. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum ToolCategory { + /// bash, execute_command, shell, run_command → commandExecution + CommandExecution, + /// write_file, edit_file, str_replace_editor, create_file, Write, Edit → fileChange + FileChange, + /// read_file, Read, Glob, Grep → commandExecution (read-only) + FileRead, + /// Unknown tools → commandExecution + Other, +} + +impl ToolCategory { + /// The Codex item `type` string for this category. + pub(crate) fn item_type(&self) -> &'static str { + match self { + ToolCategory::FileChange => "fileChange", + _ => "commandExecution", + } + } +} + +/// Classify a Claude CLI tool name into a category. +pub(crate) fn classify_tool(name: &str) -> ToolCategory { + match name { + "bash" | "execute_command" | "shell" | "run_command" | "Bash" => { + ToolCategory::CommandExecution + } + "write_file" | "edit_file" | "str_replace_editor" | "create_file" | "Write" | "Edit" + | "NotebookEdit" => ToolCategory::FileChange, + "read_file" | "Read" | "Glob" | "Grep" | "WebFetch" | "WebSearch" => { + ToolCategory::FileRead + } + _ => ToolCategory::Other, + } +} + +/// Tracks the state of a single tool-use item throughout its lifecycle. +#[derive(Debug, Clone)] +pub(crate) struct ItemInfo { + pub(crate) item_id: String, + pub(crate) tool_use_id: String, + pub(crate) tool_name: String, + pub(crate) category: ToolCategory, + /// Accumulated partial JSON from `input_json_delta` events. + pub(crate) accumulated_input_json: String, + /// Accumulated output from tool result. + pub(crate) aggregated_output: String, +} + +/// Extract a command string from the parsed tool input JSON. +/// +/// Works for bash/execute_command tools where `input.command` holds the command. +pub(crate) fn extract_command(tool_name: &str, input: &Value) -> Option { + match tool_name { + "bash" | "Bash" | "execute_command" | "shell" | "run_command" => input + .get("command") + .and_then(|v| v.as_str()) + .map(|s| s.to_string()), + _ => None, + } +} + +/// Extract a file path from the parsed tool input JSON. +/// +/// Works for file-change tools where `input.path` or `input.file_path` holds the path. +pub(crate) fn extract_file_path(tool_name: &str, input: &Value) -> Option { + match tool_name { + "write_file" | "edit_file" | "str_replace_editor" | "create_file" | "Write" | "Edit" + | "read_file" | "Read" | "NotebookEdit" => input + .get("path") + .or_else(|| input.get("file_path")) + .and_then(|v| v.as_str()) + .map(|s| s.to_string()), + _ => None, + } +} + +/// Extract a file-change kind from the tool name. +pub(crate) fn infer_change_kind(tool_name: &str) -> &'static str { + match tool_name { + "create_file" | "Write" | "write_file" => "add", + "edit_file" | "Edit" | "str_replace_editor" | "NotebookEdit" => "modify", + _ => "modify", + } +} + +/// Build the `item` object for an `item/started` event. +pub(crate) fn build_item_started( + info: &ItemInfo, + thread_id: &str, + turn_id: &str, +) -> Value { + let item_type = info.category.item_type(); + let mut item = json!({ + "id": info.item_id, + "type": item_type, + "status": "in_progress", + "toolName": info.tool_name, + "toolUseId": info.tool_use_id, + }); + + if item_type == "commandExecution" { + item["command"] = json!(""); + item["cwd"] = json!(""); + item["aggregatedOutput"] = json!(""); + } + + json!({ + "method": "item/started", + "params": { + "threadId": thread_id, + "turnId": turn_id, + "item": item, + } + }) +} + +/// Build the enriched `item/completed` event, extracting display fields +/// from the accumulated input JSON. +pub(crate) fn build_item_completed( + info: &ItemInfo, + thread_id: &str, + turn_id: &str, +) -> Value { + let parsed_input: Value = serde_json::from_str(&info.accumulated_input_json) + .unwrap_or(Value::Null); + + let mut params = json!({ + "threadId": thread_id, + "turnId": turn_id, + "itemId": info.item_id, + "status": "completed", + }); + + match info.category { + ToolCategory::CommandExecution | ToolCategory::FileRead | ToolCategory::Other => { + if let Some(cmd) = extract_command(&info.tool_name, &parsed_input) { + params["command"] = json!(cmd); + } + if !info.aggregated_output.is_empty() { + params["aggregatedOutput"] = json!(info.aggregated_output); + } + } + ToolCategory::FileChange => { + let path = extract_file_path(&info.tool_name, &parsed_input) + .unwrap_or_default(); + let kind = infer_change_kind(&info.tool_name); + + let mut change = json!({ + "path": path, + "kind": kind, + }); + if !info.aggregated_output.is_empty() { + change["diff"] = json!(info.aggregated_output); + } + params["changes"] = json!([change]); + } + } + + json!({ + "method": "item/completed", + "params": params, + }) +} + +/// Build an output delta event for streaming tool output. +pub(crate) fn build_output_delta( + info: &ItemInfo, + thread_id: &str, + turn_id: &str, + delta: &str, +) -> Value { + let method = match info.category { + ToolCategory::FileChange => "item/fileChange/outputDelta", + _ => "item/commandExecution/outputDelta", + }; + json!({ + "method": method, + "params": { + "threadId": thread_id, + "turnId": turn_id, + "itemId": info.item_id, + "delta": delta, + } + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + // ── classify_tool ──────────────────────────────────────────── + + #[test] + fn classify_bash_as_command_execution() { + assert_eq!(classify_tool("bash"), ToolCategory::CommandExecution); + assert_eq!(classify_tool("Bash"), ToolCategory::CommandExecution); + assert_eq!( + classify_tool("execute_command"), + ToolCategory::CommandExecution + ); + assert_eq!(classify_tool("shell"), ToolCategory::CommandExecution); + assert_eq!(classify_tool("run_command"), ToolCategory::CommandExecution); + } + + #[test] + fn classify_file_change_tools() { + assert_eq!(classify_tool("write_file"), ToolCategory::FileChange); + assert_eq!(classify_tool("edit_file"), ToolCategory::FileChange); + assert_eq!( + classify_tool("str_replace_editor"), + ToolCategory::FileChange + ); + assert_eq!(classify_tool("create_file"), ToolCategory::FileChange); + assert_eq!(classify_tool("Write"), ToolCategory::FileChange); + assert_eq!(classify_tool("Edit"), ToolCategory::FileChange); + assert_eq!(classify_tool("NotebookEdit"), ToolCategory::FileChange); + } + + #[test] + fn classify_file_read_tools() { + assert_eq!(classify_tool("read_file"), ToolCategory::FileRead); + assert_eq!(classify_tool("Read"), ToolCategory::FileRead); + assert_eq!(classify_tool("Glob"), ToolCategory::FileRead); + assert_eq!(classify_tool("Grep"), ToolCategory::FileRead); + assert_eq!(classify_tool("WebFetch"), ToolCategory::FileRead); + } + + #[test] + fn classify_unknown_as_other() { + assert_eq!(classify_tool("my_custom_tool"), ToolCategory::Other); + assert_eq!(classify_tool("mcp__slack__send"), ToolCategory::Other); + } + + #[test] + fn item_type_for_categories() { + assert_eq!(ToolCategory::CommandExecution.item_type(), "commandExecution"); + assert_eq!(ToolCategory::FileChange.item_type(), "fileChange"); + assert_eq!(ToolCategory::FileRead.item_type(), "commandExecution"); + assert_eq!(ToolCategory::Other.item_type(), "commandExecution"); + } + + // ── extract_command ────────────────────────────────────────── + + #[test] + fn extract_command_from_bash_input() { + let input = json!({"command": "ls -la /tmp"}); + assert_eq!( + extract_command("bash", &input), + Some("ls -la /tmp".to_string()) + ); + } + + #[test] + fn extract_command_from_execute_command_input() { + let input = json!({"command": "cargo build"}); + assert_eq!( + extract_command("execute_command", &input), + Some("cargo build".to_string()) + ); + } + + #[test] + fn extract_command_returns_none_for_non_command_tool() { + let input = json!({"command": "something"}); + assert_eq!(extract_command("write_file", &input), None); + } + + #[test] + fn extract_command_returns_none_when_field_missing() { + let input = json!({"other": "value"}); + assert_eq!(extract_command("bash", &input), None); + } + + // ── extract_file_path ──────────────────────────────────────── + + #[test] + fn extract_file_path_from_write_file() { + let input = json!({"path": "/src/main.rs", "content": "fn main() {}"}); + assert_eq!( + extract_file_path("write_file", &input), + Some("/src/main.rs".to_string()) + ); + } + + #[test] + fn extract_file_path_from_edit_file_with_file_path_key() { + let input = json!({"file_path": "/src/lib.rs"}); + assert_eq!( + extract_file_path("edit_file", &input), + Some("/src/lib.rs".to_string()) + ); + } + + #[test] + fn extract_file_path_returns_none_for_bash() { + let input = json!({"path": "/tmp"}); + assert_eq!(extract_file_path("bash", &input), None); + } + + // ── infer_change_kind ──────────────────────────────────────── + + #[test] + fn infer_kind_for_file_tools() { + assert_eq!(infer_change_kind("create_file"), "add"); + assert_eq!(infer_change_kind("Write"), "add"); + assert_eq!(infer_change_kind("write_file"), "add"); + assert_eq!(infer_change_kind("edit_file"), "modify"); + assert_eq!(infer_change_kind("Edit"), "modify"); + assert_eq!(infer_change_kind("str_replace_editor"), "modify"); + } + + // ── build_item_started ─────────────────────────────────────── + + #[test] + fn build_item_started_command_execution() { + let info = ItemInfo { + item_id: "item_1".into(), + tool_use_id: "toolu_abc".into(), + tool_name: "bash".into(), + category: ToolCategory::CommandExecution, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }; + let event = build_item_started(&info, "thread_1", "turn_1"); + assert_eq!(event["method"], "item/started"); + let item = &event["params"]["item"]; + assert_eq!(item["type"], "commandExecution"); + assert_eq!(item["id"], "item_1"); + assert_eq!(item["status"], "in_progress"); + assert_eq!(item["toolName"], "bash"); + assert_eq!(item["toolUseId"], "toolu_abc"); + assert_eq!(item["command"], ""); + assert_eq!(item["cwd"], ""); + } + + #[test] + fn build_item_started_file_change() { + let info = ItemInfo { + item_id: "item_2".into(), + tool_use_id: "toolu_xyz".into(), + tool_name: "write_file".into(), + category: ToolCategory::FileChange, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }; + let event = build_item_started(&info, "thread_1", "turn_1"); + let item = &event["params"]["item"]; + assert_eq!(item["type"], "fileChange"); + assert_eq!(item["toolName"], "write_file"); + // fileChange items don't have command/cwd fields + assert!(item.get("command").is_none()); + } + + // ── build_item_completed ───────────────────────────────────── + + #[test] + fn build_item_completed_command_with_output() { + let info = ItemInfo { + item_id: "item_3".into(), + tool_use_id: "toolu_123".into(), + tool_name: "bash".into(), + category: ToolCategory::CommandExecution, + accumulated_input_json: r#"{"command": "ls -la"}"#.into(), + aggregated_output: "total 8\ndrwxr-xr-x 2 user user 4096 Jan 1 00:00 .\n".into(), + }; + let event = build_item_completed(&info, "thread_1", "turn_1"); + assert_eq!(event["method"], "item/completed"); + let params = &event["params"]; + assert_eq!(params["itemId"], "item_3"); + assert_eq!(params["status"], "completed"); + assert_eq!(params["command"], "ls -la"); + assert!(params["aggregatedOutput"].as_str().unwrap().contains("total 8")); + } + + #[test] + fn build_item_completed_file_change_with_path() { + let info = ItemInfo { + item_id: "item_4".into(), + tool_use_id: "toolu_456".into(), + tool_name: "write_file".into(), + category: ToolCategory::FileChange, + accumulated_input_json: r#"{"path": "src/main.rs", "content": "fn main() {}"}"#.into(), + aggregated_output: String::new(), + }; + let event = build_item_completed(&info, "thread_1", "turn_1"); + let params = &event["params"]; + assert_eq!(params["status"], "completed"); + let changes = params["changes"].as_array().unwrap(); + assert_eq!(changes.len(), 1); + assert_eq!(changes[0]["path"], "src/main.rs"); + assert_eq!(changes[0]["kind"], "add"); + } + + #[test] + fn build_item_completed_edit_file_infers_modify() { + let info = ItemInfo { + item_id: "item_5".into(), + tool_use_id: "toolu_789".into(), + tool_name: "edit_file".into(), + category: ToolCategory::FileChange, + accumulated_input_json: r#"{"path": "src/lib.rs"}"#.into(), + aggregated_output: "--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -1 +1 @@\n-old\n+new\n" + .into(), + }; + let event = build_item_completed(&info, "thread_1", "turn_1"); + let changes = event["params"]["changes"].as_array().unwrap(); + assert_eq!(changes[0]["kind"], "modify"); + assert!(changes[0]["diff"].as_str().unwrap().contains("--- a/src/lib.rs")); + } + + // ── build_output_delta ─────────────────────────────────────── + + #[test] + fn build_output_delta_command_execution() { + let info = ItemInfo { + item_id: "item_6".into(), + tool_use_id: "toolu_aaa".into(), + tool_name: "bash".into(), + category: ToolCategory::CommandExecution, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }; + let event = build_output_delta(&info, "t1", "turn1", "hello world\n"); + assert_eq!(event["method"], "item/commandExecution/outputDelta"); + assert_eq!(event["params"]["delta"], "hello world\n"); + assert_eq!(event["params"]["itemId"], "item_6"); + } + + #[test] + fn build_output_delta_file_change() { + let info = ItemInfo { + item_id: "item_7".into(), + tool_use_id: "toolu_bbb".into(), + tool_name: "write_file".into(), + category: ToolCategory::FileChange, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }; + let event = build_output_delta(&info, "t1", "turn1", "diff content"); + assert_eq!(event["method"], "item/fileChange/outputDelta"); + } + + // ── build_item_completed with unparseable input ────────────── + + #[test] + fn build_item_completed_with_invalid_json_input() { + let info = ItemInfo { + item_id: "item_8".into(), + tool_use_id: "toolu_ccc".into(), + tool_name: "bash".into(), + category: ToolCategory::CommandExecution, + accumulated_input_json: "not valid json{".into(), + aggregated_output: "some output".into(), + }; + let event = build_item_completed(&info, "t1", "turn1"); + // Should not panic, gracefully handles invalid JSON + assert_eq!(event["params"]["status"], "completed"); + assert_eq!(event["params"]["aggregatedOutput"], "some output"); + } +} diff --git a/src-tauri/src/claude_bridge/mod.rs b/src-tauri/src/claude_bridge/mod.rs index df4e7cb6a..36ab71563 100644 --- a/src-tauri/src/claude_bridge/mod.rs +++ b/src-tauri/src/claude_bridge/mod.rs @@ -1,3 +1,4 @@ pub(crate) mod event_mapper; +pub(crate) mod item_tracker; pub(crate) mod process; pub(crate) mod types; diff --git a/src-tauri/src/claude_bridge/types.rs b/src-tauri/src/claude_bridge/types.rs index 3f4f5ac01..a00d57343 100644 --- a/src-tauri/src/claude_bridge/types.rs +++ b/src-tauri/src/claude_bridge/types.rs @@ -1,6 +1,8 @@ use serde::{Deserialize, Serialize}; use serde_json::Value; +use super::item_tracker::ItemInfo; + /// Represents a single event from Claude CLI's `--output-format stream-json` output. /// Each line of stdout is one JSON object with a `type` field. #[derive(Debug, Clone, Deserialize)] @@ -229,6 +231,10 @@ pub(crate) struct BridgeState { pub(crate) turn_started: bool, /// Model ID reported by Claude. pub(crate) model: Option, + /// Maps tool_use_id → ItemInfo for correlating tool results back to items. + pub(crate) tool_items: std::collections::HashMap, + /// Maps content block index → tool_use_id (to find ItemInfo from content block events). + pub(crate) block_tool_use_ids: std::collections::HashMap, } impl BridgeState { @@ -244,6 +250,8 @@ impl BridgeState { thread_started: false, turn_started: false, model: None, + tool_items: std::collections::HashMap::new(), + block_tool_use_ids: std::collections::HashMap::new(), } } @@ -257,5 +265,7 @@ impl BridgeState { self.turn_id = format!("turn_{}", uuid::Uuid::new_v4()); self.turn_started = false; self.block_items.clear(); + self.tool_items.clear(); + self.block_tool_use_ids.clear(); } } From eac6f56a02ccb28c771af2df474f3063fe397fd7 Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 07:26:43 +0000 Subject: [PATCH 05/16] feat: Phase 3 - Add Claude CLI option to backend mode settings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Expose BackendMode::Claude in the frontend UI so users can switch to Claude CLI as the AI backend from Settings → Server. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- .../settings/components/sections/SettingsServerSection.tsx | 6 ++++-- src/types.ts | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/features/settings/components/sections/SettingsServerSection.tsx b/src/features/settings/components/sections/SettingsServerSection.tsx index 7a1139d6b..45a990e96 100644 --- a/src/features/settings/components/sections/SettingsServerSection.tsx +++ b/src/features/settings/components/sections/SettingsServerSection.tsx @@ -205,10 +205,12 @@ export function SettingsServerSection({ > +
- Local keeps desktop requests in-process. Remote routes desktop requests through the same - TCP transport path used by mobile clients. + Local keeps desktop requests in-process. Remote routes requests through the TCP transport + path used by mobile clients. Claude CLI uses the locally-installed claude command as the + AI backend.
)} diff --git a/src/types.ts b/src/types.ts index a69f6bc21..02a000493 100644 --- a/src/types.ts +++ b/src/types.ts @@ -162,7 +162,7 @@ export type PullRequestSelectionRange = { }; export type AccessMode = "read-only" | "current" | "full-access"; -export type BackendMode = "local" | "remote"; +export type BackendMode = "local" | "remote" | "claude"; export type RemoteBackendProvider = "tcp"; export type RemoteBackendTarget = { id: string; From cd2de32cde9e75cabc693e4aa92db132f469f762 Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 07:30:27 +0000 Subject: [PATCH 06/16] fix: show error toast when workspace connection fails Previously connection errors were only logged to the debug panel. Now users see a visible toast notification with the failure reason, which is especially important for Claude CLI mode when the claude binary is not found in PATH. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src/features/workspaces/hooks/useWorkspaceCrud.ts | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/features/workspaces/hooks/useWorkspaceCrud.ts b/src/features/workspaces/hooks/useWorkspaceCrud.ts index f2fe84bd5..2f778d297 100644 --- a/src/features/workspaces/hooks/useWorkspaceCrud.ts +++ b/src/features/workspaces/hooks/useWorkspaceCrud.ts @@ -2,6 +2,7 @@ import { useCallback } from "react"; import type { Dispatch, MutableRefObject, SetStateAction } from "react"; import * as Sentry from "@sentry/react"; import type { DebugEntry, WorkspaceInfo, WorkspaceSettings } from "../../../types"; +import { pushErrorToast } from "../../../services/toasts"; import { addWorkspace as addWorkspaceService, addWorkspaceFromGitUrl as addWorkspaceFromGitUrlService, @@ -337,12 +338,17 @@ export function useWorkspaceCrud({ ), ); } catch (error) { + const message = error instanceof Error ? error.message : String(error); onDebug?.({ id: `${Date.now()}-client-connect-workspace-error`, timestamp: Date.now(), source: "error", label: "workspace/connect error", - payload: error instanceof Error ? error.message : String(error), + payload: message, + }); + pushErrorToast({ + title: "Workspace connection failed", + message, }); throw error; } From 758ff4fa171a14a98fec7050e068b4621c48b2c0 Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 07:47:02 +0000 Subject: [PATCH 07/16] feat: Phase 4 - Model, cost, limits & context window for Claude CLI - Accumulate total tokens and cost across turns in BridgeState - Emit token usage with last/total breakdown and modelContextWindow (200k) - Emit cost and duration in turn/completed events - Emit synthetic account/rateLimits/updated with cumulative cost display - Dynamic model list from detected session model instead of hardcoded - Format model display names (e.g. "Claude Sonnet 4" from ID) https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src-tauri/src/claude_bridge/event_mapper.rs | 196 +++++++++++++++++++- src-tauri/src/claude_bridge/process.rs | 111 ++++++++++- src-tauri/src/claude_bridge/types.rs | 9 + 3 files changed, 304 insertions(+), 12 deletions(-) diff --git a/src-tauri/src/claude_bridge/event_mapper.rs b/src-tauri/src/claude_bridge/event_mapper.rs index 150fd5d40..1e4f44dfb 100644 --- a/src-tauri/src/claude_bridge/event_mapper.rs +++ b/src-tauri/src/claude_bridge/event_mapper.rs @@ -309,12 +309,23 @@ fn map_content_block_stop( out } +/// Infer the model context window size from the model name. +fn context_window_for_model(model: Option<&str>) -> u64 { + match model { + Some(m) if m.starts_with("claude-haiku") => 200_000, + Some(m) if m.starts_with("claude-sonnet") => 200_000, + Some(m) if m.starts_with("claude-opus") => 200_000, + _ => 200_000, + } +} + fn map_message_delta( md: &super::types::MessageDeltaEvent, state: &mut BridgeState, ) -> Vec { let mut out = Vec::new(); if let Some(ref usage) = md.usage { + let ctx_window = context_window_for_model(state.model.as_deref()); out.push(json!({ "method": "thread/tokenUsage/updated", "params": { @@ -324,6 +335,7 @@ fn map_message_delta( "outputTokens": usage.output_tokens, "cacheCreationInputTokens": usage.cache_creation_input_tokens, "cacheReadInputTokens": usage.cache_read_input_tokens, + "modelContextWindow": ctx_window } } })); @@ -343,31 +355,73 @@ fn map_result( state: &mut BridgeState, ) -> Vec { let mut out = Vec::new(); + let ctx_window = context_window_for_model(state.model.as_deref()); - // Emit token usage if available + // Accumulate totals and emit token usage if let Some(ref usage) = res.usage { + state.total_input_tokens += usage.input_tokens; + state.total_output_tokens += usage.output_tokens; + + let last_total = usage.input_tokens + usage.output_tokens; + let grand_total = state.total_input_tokens + state.total_output_tokens; + out.push(json!({ "method": "thread/tokenUsage/updated", "params": { "threadId": state.thread_id, "usage": { - "inputTokens": usage.input_tokens, - "outputTokens": usage.output_tokens, - "cacheCreationInputTokens": usage.cache_creation_input_tokens, - "cacheReadInputTokens": usage.cache_read_input_tokens, + "last": { + "inputTokens": usage.input_tokens, + "outputTokens": usage.output_tokens, + "totalTokens": last_total, + "cachedInputTokens": usage.cache_read_input_tokens.unwrap_or(0), + "reasoningOutputTokens": 0 + }, + "total": { + "inputTokens": state.total_input_tokens, + "outputTokens": state.total_output_tokens, + "totalTokens": grand_total, + "cachedInputTokens": 0, + "reasoningOutputTokens": 0 + }, + "modelContextWindow": ctx_window } } })); } - // Emit turn/completed + // Accumulate cost + if let Some(cost) = res.cost_usd { + state.total_cost_usd += cost; + } + + // Emit turn/completed with cost and duration if state.turn_started { out.push(json!({ "method": "turn/completed", "params": { "threadId": state.thread_id, "turnId": state.turn_id, - "status": if res.is_error { "error" } else { "completed" } + "status": if res.is_error { "error" } else { "completed" }, + "costUsd": res.cost_usd, + "durationMs": res.duration_ms + } + })); + } + + // Emit rate limits with cumulative cost display + if state.total_cost_usd > 0.0 { + out.push(json!({ + "method": "account/rateLimits/updated", + "params": { + "primary": null, + "secondary": null, + "credits": { + "hasCredits": true, + "unlimited": false, + "balance": format!("${:.2} spent", state.total_cost_usd) + }, + "planType": "claude-cli" } })); } @@ -909,4 +963,132 @@ mod tests { assert!(state.tool_items.is_empty()); assert!(state.block_tool_use_ids.is_empty()); } + + // ── Phase 4: Model, Cost, Limits & Context Window ──────────── + + #[test] + fn result_event_accumulates_total_tokens() { + let mut state = make_state(); + state.turn_started = true; + + let event1 = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: Some(0.01), + usage: Some(UsageInfo { + input_tokens: 100, output_tokens: 50, + cache_creation_input_tokens: None, cache_read_input_tokens: None, + }), + extra: Default::default(), + }); + map_event(&event1, &mut state); + + assert_eq!(state.total_input_tokens, 100); + assert_eq!(state.total_output_tokens, 50); + assert!((state.total_cost_usd - 0.01).abs() < f64::EPSILON); + + // Second turn + state.turn_started = true; + let event2 = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: Some(0.02), + usage: Some(UsageInfo { + input_tokens: 200, output_tokens: 100, + cache_creation_input_tokens: None, cache_read_input_tokens: None, + }), + extra: Default::default(), + }); + map_event(&event2, &mut state); + + assert_eq!(state.total_input_tokens, 300); + assert_eq!(state.total_output_tokens, 150); + assert!((state.total_cost_usd - 0.03).abs() < f64::EPSILON); + } + + #[test] + fn result_event_emits_model_context_window() { + let mut state = make_state(); + state.turn_started = true; + state.model = Some("claude-sonnet-4-20250514".to_string()); + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: None, + usage: Some(UsageInfo { + input_tokens: 100, output_tokens: 50, + cache_creation_input_tokens: None, cache_read_input_tokens: None, + }), + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + + let token_msg = msgs.iter() + .find(|m| m["method"] == "thread/tokenUsage/updated") + .unwrap(); + assert_eq!(token_msg["params"]["usage"]["modelContextWindow"], 200_000); + assert_eq!(token_msg["params"]["usage"]["last"]["totalTokens"], 150); + assert_eq!(token_msg["params"]["usage"]["total"]["totalTokens"], 150); + } + + #[test] + fn result_event_emits_rate_limits_with_cost() { + let mut state = make_state(); + state.turn_started = true; + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: Some(0.42), + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + + let rate_msg = msgs.iter() + .find(|m| m["method"] == "account/rateLimits/updated") + .unwrap(); + assert_eq!(rate_msg["params"]["credits"]["hasCredits"], true); + assert_eq!(rate_msg["params"]["credits"]["balance"], "$0.42 spent"); + assert_eq!(rate_msg["params"]["planType"], "claude-cli"); + } + + #[test] + fn result_event_includes_cost_in_turn_completed() { + let mut state = make_state(); + state.turn_started = true; + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: Some(3200), duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: Some(0.05), + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + + let turn_msg = msgs.iter() + .find(|m| m["method"] == "turn/completed") + .unwrap(); + assert_eq!(turn_msg["params"]["costUsd"], 0.05); + assert_eq!(turn_msg["params"]["durationMs"], 3200); + assert_eq!(turn_msg["params"]["status"], "completed"); + } + + #[test] + fn message_delta_includes_model_context_window() { + let mut state = make_state(); + state.model = Some("claude-opus-4-20250514".to_string()); + + let event = ClaudeEvent::MessageDelta(MessageDeltaEvent { + delta: None, + usage: Some(UsageInfo { + input_tokens: 50, output_tokens: 25, + cache_creation_input_tokens: None, cache_read_input_tokens: None, + }), + }); + let msgs = map_event(&event, &mut state); + assert_eq!(msgs[0]["params"]["usage"]["modelContextWindow"], 200_000); + } } diff --git a/src-tauri/src/claude_bridge/process.rs b/src-tauri/src/claude_bridge/process.rs index affa42a2b..3a337d7e1 100644 --- a/src-tauri/src/claude_bridge/process.rs +++ b/src-tauri/src/claude_bridge/process.rs @@ -60,15 +60,25 @@ pub(crate) async fn spawn_claude_session( let workspace_id = entry.id.clone(); let workspace_path = entry.path.clone(); + // Shared model name: updated by event loop, read by interceptor + let detected_model: Arc>> = + Arc::new(std::sync::Mutex::new(None)); + let detected_model_for_interceptor = detected_model.clone(); + // Build the request interceptor for Claude CLI protocol translation let interceptor_thread_id = thread_id.clone(); let interceptor_workspace_id = workspace_id.clone(); let interceptor: Arc InterceptAction + Send + Sync> = Arc::new(move |value: Value| { + let model = detected_model_for_interceptor + .lock() + .ok() + .and_then(|g| g.clone()); build_claude_intercept_action( &value, &interceptor_thread_id, &interceptor_workspace_id, + model.as_deref(), ) }); @@ -95,6 +105,7 @@ pub(crate) async fn spawn_claude_session( let event_sink_stdout = event_sink.clone(); let ws_id_stdout = workspace_id.clone(); let stdout_thread_id = thread_id.clone(); + let detected_model_for_loop = detected_model.clone(); tokio::spawn(async move { let mut bridge_state = BridgeState::new(ws_id_stdout.clone(), stdout_thread_id); let mut lines = BufReader::new(stdout).lines(); @@ -119,6 +130,16 @@ pub(crate) async fn spawn_claude_session( }; let codex_messages = event_mapper::map_event(&claude_event, &mut bridge_state); + + // Propagate detected model to the shared interceptor state + if let Some(ref model) = bridge_state.model { + if let Ok(mut guard) = detected_model_for_loop.lock() { + if guard.as_ref() != Some(model) { + *guard = Some(model.clone()); + } + } + } + for message in codex_messages { let payload = AppServerEvent { workspace_id: ws_id_stdout.clone(), @@ -162,11 +183,42 @@ pub(crate) async fn spawn_claude_session( Ok(session) } +/// Format a model ID like "claude-sonnet-4-20250514" into a display name +/// like "Claude Sonnet 4". +fn format_model_display_name(model_id: &str) -> String { + // Strip date suffix (e.g. "-20250514") + let base = if let Some(pos) = model_id.rfind('-') { + let suffix = &model_id[pos + 1..]; + if suffix.len() == 8 && suffix.chars().all(|c| c.is_ascii_digit()) { + &model_id[..pos] + } else { + model_id + } + } else { + model_id + }; + // Capitalize each segment + base.split('-') + .map(|s| { + let mut c = s.chars(); + match c.next() { + None => String::new(), + Some(first) => { + let upper: String = first.to_uppercase().collect(); + upper + c.as_str() + } + } + }) + .collect::>() + .join(" ") +} + /// Determine how to handle a JSON-RPC message destined for Claude CLI. fn build_claude_intercept_action( value: &Value, thread_id: &str, _workspace_id: &str, + detected_model: Option<&str>, ) -> InterceptAction { let method = value .get("method") @@ -279,13 +331,20 @@ fn build_claude_intercept_action( "model/list" => { if let Some(id) = id { + let model_id = detected_model.unwrap_or("claude-sonnet-4-20250514"); + let display_name = format_model_display_name(model_id); InterceptAction::Respond(json!({ "id": id, "result": { "data": [{ - "id": "claude-sonnet-4-20250514", - "name": "Claude Sonnet 4", - "isDefault": true + "id": model_id, + "model": model_id, + "displayName": display_name, + "name": display_name, + "isDefault": true, + "supportedReasoningEfforts": [], + "defaultReasoningEffort": null, + "description": "Claude CLI" }] } })) @@ -411,7 +470,7 @@ mod tests { #[test] fn intercept_initialize_responds_immediately() { let action = - build_claude_intercept_action(&json!({"id": 1, "method": "initialize"}), "t1", "w1"); + build_claude_intercept_action(&json!({"id": 1, "method": "initialize"}), "t1", "w1", None); match action { InterceptAction::Respond(v) => { assert_eq!(v["id"], 1); @@ -433,6 +492,7 @@ mod tests { }), "t1", "w1", + None, ); match action { InterceptAction::Forward(text) => assert_eq!(text, "What is Rust?"), @@ -446,6 +506,7 @@ mod tests { &json!({"id": 3, "method": "thread/list"}), "thread_abc", "ws_1", + None, ); match action { InterceptAction::Respond(v) => { @@ -463,6 +524,7 @@ mod tests { &json!({"id": 4, "method": "some/unknown"}), "t1", "w1", + None, ); match action { InterceptAction::Respond(v) => { @@ -475,7 +537,7 @@ mod tests { #[test] fn intercept_notification_drops_initialized() { let action = - build_claude_intercept_action(&json!({"method": "initialized"}), "t1", "w1"); + build_claude_intercept_action(&json!({"method": "initialized"}), "t1", "w1", None); assert!(matches!(action, InterceptAction::Drop)); } @@ -489,6 +551,7 @@ mod tests { }), "t1", "w1", + None, ); match action { InterceptAction::Respond(v) => { @@ -497,4 +560,42 @@ mod tests { _ => panic!("Expected Respond with error"), } } + + #[test] + fn format_model_display_name_strips_date() { + assert_eq!( + format_model_display_name("claude-sonnet-4-20250514"), + "Claude Sonnet 4" + ); + assert_eq!( + format_model_display_name("claude-opus-4-20250514"), + "Claude Opus 4" + ); + } + + #[test] + fn format_model_display_name_without_date() { + assert_eq!( + format_model_display_name("claude-haiku-4"), + "Claude Haiku 4" + ); + } + + #[test] + fn intercept_model_list_uses_detected_model() { + let action = build_claude_intercept_action( + &json!({"id": 10, "method": "model/list"}), + "t1", + "w1", + Some("claude-opus-4-20250514"), + ); + match action { + InterceptAction::Respond(v) => { + let data = v["result"]["data"].as_array().unwrap(); + assert_eq!(data[0]["model"], "claude-opus-4-20250514"); + assert_eq!(data[0]["displayName"], "Claude Opus 4"); + } + _ => panic!("Expected Respond"), + } + } } diff --git a/src-tauri/src/claude_bridge/types.rs b/src-tauri/src/claude_bridge/types.rs index a00d57343..b77ec7cb9 100644 --- a/src-tauri/src/claude_bridge/types.rs +++ b/src-tauri/src/claude_bridge/types.rs @@ -235,6 +235,12 @@ pub(crate) struct BridgeState { pub(crate) tool_items: std::collections::HashMap, /// Maps content block index → tool_use_id (to find ItemInfo from content block events). pub(crate) block_tool_use_ids: std::collections::HashMap, + /// Cumulative input tokens across all turns. + pub(crate) total_input_tokens: u64, + /// Cumulative output tokens across all turns. + pub(crate) total_output_tokens: u64, + /// Cumulative cost in USD across all turns. + pub(crate) total_cost_usd: f64, } impl BridgeState { @@ -252,6 +258,9 @@ impl BridgeState { model: None, tool_items: std::collections::HashMap::new(), block_tool_use_ids: std::collections::HashMap::new(), + total_input_tokens: 0, + total_output_tokens: 0, + total_cost_usd: 0.0, } } From 1f2af29ca47bf3a2aa04f527b9562719c839141c Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 08:09:52 +0000 Subject: [PATCH 08/16] feat: Phase 5 - Comprehensive tests for Claude CLI bridge Add 75+ new tests across all claude_bridge modules: - types.rs: ClaudeEvent deserialization for all event types, BridgeState lifecycle - event_mapper.rs: edge cases for assistant events, extract_tool_result_text, context windows, content block tracking, result event conditional outputs - process.rs: full interceptor coverage for all JSON-RPC methods (turn/steer, thread/resume, thread/fork, skills/list, account/read, model/list fallback, notification drops) Total: 138 claude_bridge tests passing. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src-tauri/src/claude_bridge/event_mapper.rs | 367 +++++++++++++++++ src-tauri/src/claude_bridge/process.rs | 431 ++++++++++++++++++++ src-tauri/src/claude_bridge/types.rs | 400 ++++++++++++++++++ 3 files changed, 1198 insertions(+) diff --git a/src-tauri/src/claude_bridge/event_mapper.rs b/src-tauri/src/claude_bridge/event_mapper.rs index 1e4f44dfb..13816c3a1 100644 --- a/src-tauri/src/claude_bridge/event_mapper.rs +++ b/src-tauri/src/claude_bridge/event_mapper.rs @@ -1091,4 +1091,371 @@ mod tests { let msgs = map_event(&event, &mut state); assert_eq!(msgs[0]["params"]["usage"]["modelContextWindow"], 200_000); } + + // ── Phase 5: Additional edge-case tests ─────────────────────── + + #[test] + fn assistant_text_subtype_produces_message_delta() { + let mut state = make_state(); + state.turn_started = true; + + let event = ClaudeEvent::Assistant(AssistantEvent { + subtype: Some("text".to_string()), + message: Some(serde_json::json!("Hello from assistant")), + content_block: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert_eq!(msgs.len(), 1); + assert_eq!(msgs[0]["method"], "item/agentMessage/delta"); + assert_eq!(msgs[0]["params"]["delta"], "Hello from assistant"); + assert_eq!(state.accumulated_text, "Hello from assistant"); + } + + #[test] + fn assistant_text_creates_item_if_none_exists() { + let mut state = make_state(); + assert!(state.block_items.is_empty()); + + let event = ClaudeEvent::Assistant(AssistantEvent { + subtype: Some("text".to_string()), + message: Some(serde_json::json!("First message")), + content_block: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert_eq!(msgs.len(), 1); + // An item should have been auto-created + assert!(!state.block_items.is_empty()); + assert_eq!(msgs[0]["params"]["itemId"], "item_1"); + } + + #[test] + fn assistant_text_reuses_existing_item() { + let mut state = make_state(); + state.block_items.insert(0, "item_existing".to_string()); + + let event = ClaudeEvent::Assistant(AssistantEvent { + subtype: Some("text".to_string()), + message: Some(serde_json::json!("More text")), + content_block: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert_eq!(msgs[0]["params"]["itemId"], "item_existing"); + } + + #[test] + fn assistant_non_text_subtype_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::Assistant(AssistantEvent { + subtype: Some("other".to_string()), + message: Some(serde_json::json!("ignored")), + content_block: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn assistant_none_subtype_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::Assistant(AssistantEvent { + subtype: None, + message: Some(serde_json::json!("ignored")), + content_block: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn extract_tool_result_text_from_none() { + assert_eq!(extract_tool_result_text(None), ""); + } + + #[test] + fn extract_tool_result_text_from_string_value() { + let val = serde_json::json!("direct output"); + assert_eq!(extract_tool_result_text(Some(&val)), "direct output"); + } + + #[test] + fn extract_tool_result_text_from_array() { + let val = serde_json::json!([ + {"type": "text", "text": "line1"}, + {"type": "text", "text": "line2"} + ]); + assert_eq!(extract_tool_result_text(Some(&val)), "line1\nline2"); + } + + #[test] + fn extract_tool_result_text_from_array_skips_non_text() { + let val = serde_json::json!([ + {"type": "image", "url": "data:..."}, + {"type": "text", "text": "only text"} + ]); + assert_eq!(extract_tool_result_text(Some(&val)), "only text"); + } + + #[test] + fn extract_tool_result_text_from_non_string_non_array() { + let val = serde_json::json!(42); + assert_eq!(extract_tool_result_text(Some(&val)), ""); + } + + #[test] + fn extract_tool_result_text_from_empty_array() { + let val = serde_json::json!([]); + assert_eq!(extract_tool_result_text(Some(&val)), ""); + } + + #[test] + fn context_window_defaults_to_200k() { + assert_eq!(context_window_for_model(None), 200_000); + assert_eq!(context_window_for_model(Some("unknown-model")), 200_000); + } + + #[test] + fn context_window_for_known_models() { + assert_eq!(context_window_for_model(Some("claude-haiku-4")), 200_000); + assert_eq!(context_window_for_model(Some("claude-sonnet-4-20250514")), 200_000); + assert_eq!(context_window_for_model(Some("claude-opus-4-20250514")), 200_000); + } + + #[test] + fn message_start_does_not_duplicate_turn_started() { + let mut state = make_state(); + state.turn_started = true; // already started + + let event = ClaudeEvent::MessageStart(MessageStartEvent { + message: Some(MessageInfo { + id: Some("msg_2".to_string()), + role: Some("assistant".to_string()), + model: None, + usage: None, + }), + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); // no duplicate turn/started + } + + #[test] + fn message_start_updates_model() { + let mut state = make_state(); + assert!(state.model.is_none()); + + let event = ClaudeEvent::MessageStart(MessageStartEvent { + message: Some(MessageInfo { + id: None, + role: None, + model: Some("claude-opus-4-20250514".to_string()), + usage: None, + }), + }); + map_event(&event, &mut state); + assert_eq!(state.model.as_deref(), Some("claude-opus-4-20250514")); + } + + #[test] + fn message_stop_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::MessageStop(MessageStopEvent { + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn content_block_start_without_block_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: None, + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn content_block_delta_without_item_produces_nothing() { + let mut state = make_state(); + // No block_items registered for index 5 + let event = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 5, + delta: Some(ContentBlockDelta::TextDelta { + text: "orphan".to_string(), + }), + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn content_block_delta_without_delta_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: None, + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn content_block_stop_without_registered_item_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::ContentBlockStop(ContentBlockStopEvent { index: 99 }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } + + #[test] + fn result_without_turn_started_skips_turn_completed() { + let mut state = make_state(); + assert!(!state.turn_started); + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: None, + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + let has_turn_completed = msgs.iter().any(|m| m["method"] == "turn/completed"); + assert!(!has_turn_completed); + } + + #[test] + fn result_without_cost_skips_rate_limits() { + let mut state = make_state(); + state.turn_started = true; + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: None, + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + let has_rate_limits = msgs.iter().any(|m| m["method"] == "account/rateLimits/updated"); + assert!(!has_rate_limits); + } + + #[test] + fn result_without_text_skips_thread_name() { + let mut state = make_state(); + state.turn_started = true; + assert!(state.accumulated_text.is_empty()); + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: None, + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + let has_name = msgs.iter().any(|m| m["method"] == "thread/name/updated"); + assert!(!has_name); + } + + #[test] + fn result_thread_name_truncated_to_38_chars() { + let mut state = make_state(); + state.turn_started = true; + state.accumulated_text = "A".repeat(100); + + let event = ClaudeEvent::Result(ResultEvent { + subtype: None, result: None, error: None, + duration_ms: None, duration_api_ms: None, num_turns: None, + is_error: false, session_id: None, cost_usd: None, + usage: None, + extra: Default::default(), + }); + let msgs = map_event(&event, &mut state); + let name_msg = msgs.iter().find(|m| m["method"] == "thread/name/updated").unwrap(); + let name = name_msg["params"]["name"].as_str().unwrap(); + assert_eq!(name.len(), 38); + } + + #[test] + fn multiple_content_blocks_tracked_independently() { + let mut state = make_state(); + state.turn_started = true; + + // Start text block at index 0 + let start0 = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::Text { text: String::new() }), + }); + let msgs0 = map_event(&start0, &mut state); + let item_0 = msgs0[0]["params"]["item"]["id"].as_str().unwrap().to_string(); + + // Start thinking block at index 1 + let start1 = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 1, + content_block: Some(ContentBlock::Thinking { thinking: String::new() }), + }); + let msgs1 = map_event(&start1, &mut state); + let item_1 = msgs1[0]["params"]["item"]["id"].as_str().unwrap().to_string(); + + assert_ne!(item_0, item_1); + + // Delta for index 0 → uses item_0 + let delta0 = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::TextDelta { text: "text".to_string() }), + }); + let msgs = map_event(&delta0, &mut state); + assert_eq!(msgs[0]["params"]["itemId"], item_0); + + // Delta for index 1 → uses item_1 + let delta1 = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 1, + delta: Some(ContentBlockDelta::ThinkingDelta { thinking: "think".to_string() }), + }); + let msgs = map_event(&delta1, &mut state); + assert_eq!(msgs[0]["params"]["itemId"], item_1); + } + + #[test] + fn text_deltas_accumulate_in_state() { + let mut state = make_state(); + state.turn_started = true; + + // Start text block + let start = ClaudeEvent::ContentBlockStart(ContentBlockEvent { + index: 0, + content_block: Some(ContentBlock::Text { text: String::new() }), + }); + map_event(&start, &mut state); + + // Send multiple deltas + for word in &["Hello", " ", "world", "!"] { + let delta = ClaudeEvent::ContentBlockDelta(ContentBlockDeltaEvent { + index: 0, + delta: Some(ContentBlockDelta::TextDelta { text: word.to_string() }), + }); + map_event(&delta, &mut state); + } + + assert_eq!(state.accumulated_text, "Hello world!"); + } + + #[test] + fn message_delta_without_usage_produces_nothing() { + let mut state = make_state(); + let event = ClaudeEvent::MessageDelta(MessageDeltaEvent { + delta: Some(serde_json::json!({"stop_reason": "end_turn"})), + usage: None, + }); + let msgs = map_event(&event, &mut state); + assert!(msgs.is_empty()); + } } diff --git a/src-tauri/src/claude_bridge/process.rs b/src-tauri/src/claude_bridge/process.rs index 3a337d7e1..9cb9e1fab 100644 --- a/src-tauri/src/claude_bridge/process.rs +++ b/src-tauri/src/claude_bridge/process.rs @@ -598,4 +598,435 @@ mod tests { _ => panic!("Expected Respond"), } } + + // ── Phase 5: Additional interceptor tests ───────────────────── + + #[test] + fn intercept_model_list_fallback_when_no_detected_model() { + let action = build_claude_intercept_action( + &json!({"id": 11, "method": "model/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + let data = v["result"]["data"].as_array().unwrap(); + assert_eq!(data[0]["model"], "claude-sonnet-4-20250514"); + assert_eq!(data[0]["isDefault"], true); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_turn_steer_forwards_text() { + let action = build_claude_intercept_action( + &json!({ + "id": 20, + "method": "turn/steer", + "params": { "text": "Actually, do this instead" } + }), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Forward(text) => assert_eq!(text, "Actually, do this instead"), + _ => panic!("Expected Forward"), + } + } + + #[test] + fn intercept_turn_steer_empty_returns_error() { + let action = build_claude_intercept_action( + &json!({ + "id": 21, + "method": "turn/steer", + "params": {} + }), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert!(v["error"]["message"].as_str().unwrap().contains("Empty steer")); + } + _ => panic!("Expected Respond with error"), + } + } + + #[test] + fn intercept_turn_steer_empty_no_id_drops() { + let action = build_claude_intercept_action( + &json!({ + "method": "turn/steer", + "params": {} + }), + "t1", + "w1", + None, + ); + assert!(matches!(action, InterceptAction::Drop)); + } + + #[test] + fn intercept_thread_start_responds_with_thread() { + let action = build_claude_intercept_action( + &json!({"id": 30, "method": "thread/start"}), + "thread_xyz", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 30); + assert_eq!(v["result"]["threadId"], "thread_xyz"); + assert_eq!(v["result"]["thread"]["status"], "active"); + assert_eq!(v["result"]["thread"]["name"], "New conversation"); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_thread_resume_responds() { + let action = build_claude_intercept_action( + &json!({"id": 31, "method": "thread/resume"}), + "thread_abc", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["threadId"], "thread_abc"); + assert_eq!(v["result"]["thread"]["status"], "active"); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_thread_fork_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 32, "method": "thread/fork"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 32); + assert_eq!(v["result"]["ok"], true); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_thread_archive_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 33, "method": "thread/archive"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["result"]["ok"], true), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_thread_compact_start_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 34, "method": "thread/compact/start"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["result"]["ok"], true), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_thread_name_set_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 35, "method": "thread/name/set"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["result"]["ok"], true), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_review_start_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 36, "method": "review/start"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["result"]["ok"], true), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_skills_list_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 40, "method": "skills/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["data"].as_array().unwrap().len(), 0); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_app_list_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 41, "method": "app/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["data"].as_array().unwrap().len(), 0); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_mcp_server_status_list_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 42, "method": "mcpServerStatus/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["data"].as_array().unwrap().len(), 0); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_experimental_feature_list_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 43, "method": "experimentalFeature/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["data"].as_array().unwrap().len(), 0); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_collaboration_mode_list_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 44, "method": "collaborationMode/list"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["result"]["data"].as_array().unwrap().len(), 0); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_account_read_responds_empty() { + let action = build_claude_intercept_action( + &json!({"id": 50, "method": "account/read"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 50); + assert!(v["result"].is_object()); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_account_rate_limits_read_responds() { + let action = build_claude_intercept_action( + &json!({"id": 51, "method": "account/rateLimits/read"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["id"], 51), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_account_login_start_responds() { + let action = build_claude_intercept_action( + &json!({"id": 52, "method": "account/login/start"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => assert_eq!(v["id"], 52), + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_turn_interrupt_responds_ok() { + let action = build_claude_intercept_action( + &json!({"id": 60, "method": "turn/interrupt"}), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Respond(v) => { + assert_eq!(v["id"], 60); + assert_eq!(v["result"]["ok"], true); + } + _ => panic!("Expected Respond"), + } + } + + #[test] + fn intercept_notification_without_id_drops() { + for method in &["thread/start", "thread/list", "model/list", "turn/interrupt", "skills/list", "account/read"] { + let action = build_claude_intercept_action( + &json!({"method": method}), + "t1", + "w1", + None, + ); + assert!( + matches!(action, InterceptAction::Drop), + "Expected Drop for notification {method} without id" + ); + } + } + + #[test] + fn intercept_turn_start_empty_input_no_id_drops() { + let action = build_claude_intercept_action( + &json!({ + "method": "turn/start", + "params": { "input": [] } + }), + "t1", + "w1", + None, + ); + assert!(matches!(action, InterceptAction::Drop)); + } + + #[test] + fn intercept_unknown_method_no_id_drops() { + let action = build_claude_intercept_action( + &json!({"method": "completely/unknown"}), + "t1", + "w1", + None, + ); + assert!(matches!(action, InterceptAction::Drop)); + } + + #[test] + fn extract_user_text_multiple_text_items_joined() { + let params = json!({ + "input": [ + { "type": "text", "text": "Hello" }, + { "type": "text", "text": "World" } + ] + }); + assert_eq!(extract_user_text(¶ms), "Hello\nWorld"); + } + + #[test] + fn extract_user_text_prefers_input_over_text() { + let params = json!({ + "input": [{ "type": "text", "text": "from input" }], + "text": "from text field" + }); + assert_eq!(extract_user_text(¶ms), "from input"); + } + + #[test] + fn format_model_display_name_single_segment() { + assert_eq!(format_model_display_name("claude"), "Claude"); + } + + #[test] + fn format_model_display_name_with_non_date_suffix() { + assert_eq!( + format_model_display_name("claude-sonnet-4-beta"), + "Claude Sonnet 4 Beta" + ); + } + + #[test] + fn format_model_display_name_empty() { + assert_eq!(format_model_display_name(""), ""); + } + + #[test] + fn intercept_turn_start_with_text_field() { + let action = build_claude_intercept_action( + &json!({ + "id": 70, + "method": "turn/start", + "params": { "text": "Simple text" } + }), + "t1", + "w1", + None, + ); + match action { + InterceptAction::Forward(text) => assert_eq!(text, "Simple text"), + _ => panic!("Expected Forward"), + } + } + + #[test] + fn intercept_initialize_without_id_drops() { + let action = build_claude_intercept_action( + &json!({"method": "initialize"}), + "t1", + "w1", + None, + ); + assert!(matches!(action, InterceptAction::Drop)); + } } diff --git a/src-tauri/src/claude_bridge/types.rs b/src-tauri/src/claude_bridge/types.rs index b77ec7cb9..53e7d8166 100644 --- a/src-tauri/src/claude_bridge/types.rs +++ b/src-tauri/src/claude_bridge/types.rs @@ -278,3 +278,403 @@ impl BridgeState { self.block_tool_use_ids.clear(); } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::claude_bridge::item_tracker::ToolCategory; + use serde_json::json; + + // ── ClaudeEvent deserialization ──────────────────────────────── + + #[test] + fn deserialize_system_event() { + let json_str = r#"{"type":"system","subtype":"init","session_id":"sess_abc","model":"claude-sonnet-4-20250514","tools":[{"name":"bash"}]}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::System(sys) => { + assert_eq!(sys.subtype.as_deref(), Some("init")); + assert_eq!(sys.session_id.as_deref(), Some("sess_abc")); + assert_eq!(sys.model.as_deref(), Some("claude-sonnet-4-20250514")); + assert_eq!(sys.tools.as_ref().unwrap().len(), 1); + } + _ => panic!("Expected System event"), + } + } + + #[test] + fn deserialize_system_event_minimal() { + let json_str = r#"{"type":"system"}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::System(sys) => { + assert!(sys.subtype.is_none()); + assert!(sys.session_id.is_none()); + assert!(sys.model.is_none()); + assert!(sys.tools.is_none()); + } + _ => panic!("Expected System event"), + } + } + + #[test] + fn deserialize_assistant_event() { + let json_str = r#"{"type":"assistant","subtype":"text","message":"Hello"}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::Assistant(a) => { + assert_eq!(a.subtype.as_deref(), Some("text")); + assert_eq!(a.message, Some(json!("Hello"))); + } + _ => panic!("Expected Assistant event"), + } + } + + #[test] + fn deserialize_content_block_start_text() { + let json_str = r#"{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStart(cb) => { + assert_eq!(cb.index, 0); + assert!(matches!(cb.content_block, Some(ContentBlock::Text { .. }))); + } + _ => panic!("Expected ContentBlockStart"), + } + } + + #[test] + fn deserialize_content_block_start_thinking() { + let json_str = r#"{"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":""}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStart(cb) => { + assert_eq!(cb.index, 1); + assert!(matches!(cb.content_block, Some(ContentBlock::Thinking { .. }))); + } + _ => panic!("Expected ContentBlockStart"), + } + } + + #[test] + fn deserialize_content_block_start_tool_use() { + let json_str = r#"{"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_123","name":"bash","input":{}}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStart(cb) => { + match cb.content_block.unwrap() { + ContentBlock::ToolUse { id, name, .. } => { + assert_eq!(id, "toolu_123"); + assert_eq!(name, "bash"); + } + _ => panic!("Expected ToolUse"), + } + } + _ => panic!("Expected ContentBlockStart"), + } + } + + #[test] + fn deserialize_content_block_start_tool_result() { + let json_str = r#"{"type":"content_block_start","index":1,"content_block":{"type":"tool_result","tool_use_id":"toolu_123","content":"output text"}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStart(cb) => { + match cb.content_block.unwrap() { + ContentBlock::ToolResult { tool_use_id, content } => { + assert_eq!(tool_use_id.as_deref(), Some("toolu_123")); + assert_eq!(content, Some(json!("output text"))); + } + _ => panic!("Expected ToolResult"), + } + } + _ => panic!("Expected ContentBlockStart"), + } + } + + #[test] + fn deserialize_content_block_delta_text() { + let json_str = r#"{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockDelta(cbd) => { + assert_eq!(cbd.index, 0); + match cbd.delta.unwrap() { + ContentBlockDelta::TextDelta { text } => assert_eq!(text, "Hello"), + _ => panic!("Expected TextDelta"), + } + } + _ => panic!("Expected ContentBlockDelta"), + } + } + + #[test] + fn deserialize_content_block_delta_thinking() { + let json_str = r#"{"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Let me think"}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockDelta(cbd) => { + match cbd.delta.unwrap() { + ContentBlockDelta::ThinkingDelta { thinking } => { + assert_eq!(thinking, "Let me think"); + } + _ => panic!("Expected ThinkingDelta"), + } + } + _ => panic!("Expected ContentBlockDelta"), + } + } + + #[test] + fn deserialize_content_block_delta_input_json() { + let json_str = r#"{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"command\":\"ls\"}"}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockDelta(cbd) => { + match cbd.delta.unwrap() { + ContentBlockDelta::InputJsonDelta { partial_json } => { + assert_eq!(partial_json, r#"{"command":"ls"}"#); + } + _ => panic!("Expected InputJsonDelta"), + } + } + _ => panic!("Expected ContentBlockDelta"), + } + } + + #[test] + fn deserialize_content_block_stop() { + let json_str = r#"{"type":"content_block_stop","index":2}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStop(cbs) => assert_eq!(cbs.index, 2), + _ => panic!("Expected ContentBlockStop"), + } + } + + #[test] + fn deserialize_message_start() { + let json_str = r#"{"type":"message_start","message":{"id":"msg_abc","role":"assistant","model":"claude-sonnet-4-20250514","usage":{"input_tokens":100,"output_tokens":0}}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::MessageStart(ms) => { + let info = ms.message.unwrap(); + assert_eq!(info.id.as_deref(), Some("msg_abc")); + assert_eq!(info.role.as_deref(), Some("assistant")); + assert_eq!(info.model.as_deref(), Some("claude-sonnet-4-20250514")); + let usage = info.usage.unwrap(); + assert_eq!(usage.input_tokens, 100); + assert_eq!(usage.output_tokens, 0); + } + _ => panic!("Expected MessageStart"), + } + } + + #[test] + fn deserialize_message_delta() { + let json_str = r#"{"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":0,"output_tokens":50}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::MessageDelta(md) => { + assert!(md.delta.is_some()); + let usage = md.usage.unwrap(); + assert_eq!(usage.output_tokens, 50); + } + _ => panic!("Expected MessageDelta"), + } + } + + #[test] + fn deserialize_message_stop() { + let json_str = r#"{"type":"message_stop"}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + assert!(matches!(event, ClaudeEvent::MessageStop(_))); + } + + #[test] + fn deserialize_result_event() { + let json_str = r#"{"type":"result","subtype":"success","is_error":false,"duration_ms":1500,"duration_api_ms":1200,"num_turns":1,"session_id":"sess_xyz","cost_usd":0.015,"usage":{"input_tokens":200,"output_tokens":100,"cache_creation_input_tokens":10,"cache_read_input_tokens":5}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::Result(res) => { + assert_eq!(res.subtype.as_deref(), Some("success")); + assert!(!res.is_error); + assert_eq!(res.duration_ms, Some(1500)); + assert_eq!(res.duration_api_ms, Some(1200)); + assert_eq!(res.num_turns, Some(1)); + assert_eq!(res.session_id.as_deref(), Some("sess_xyz")); + assert!((res.cost_usd.unwrap() - 0.015).abs() < f64::EPSILON); + let usage = res.usage.unwrap(); + assert_eq!(usage.input_tokens, 200); + assert_eq!(usage.output_tokens, 100); + assert_eq!(usage.cache_creation_input_tokens, Some(10)); + assert_eq!(usage.cache_read_input_tokens, Some(5)); + } + _ => panic!("Expected Result event"), + } + } + + #[test] + fn deserialize_result_error() { + let json_str = r#"{"type":"result","is_error":true,"error":"API rate limited"}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::Result(res) => { + assert!(res.is_error); + assert_eq!(res.error.as_deref(), Some("API rate limited")); + } + _ => panic!("Expected Result event"), + } + } + + #[test] + fn deserialize_unknown_event_type() { + let json_str = r#"{"type":"ping","timestamp":12345}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + assert!(matches!(event, ClaudeEvent::Unknown)); + } + + #[test] + fn deserialize_content_block_with_unknown_type() { + let json_str = r#"{"type":"content_block_start","index":0,"content_block":{"type":"image","data":"base64..."}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockStart(cb) => { + assert!(matches!(cb.content_block, Some(ContentBlock::Other))); + } + _ => panic!("Expected ContentBlockStart"), + } + } + + #[test] + fn deserialize_content_block_delta_unknown_type() { + let json_str = r#"{"type":"content_block_delta","index":0,"delta":{"type":"something_new","data":"..."}}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::ContentBlockDelta(cbd) => { + assert!(matches!(cbd.delta, Some(ContentBlockDelta::Other))); + } + _ => panic!("Expected ContentBlockDelta"), + } + } + + #[test] + fn deserialize_system_event_with_extra_fields() { + let json_str = r#"{"type":"system","model":"claude-sonnet-4-20250514","custom_field":"custom_value","another":42}"#; + let event: ClaudeEvent = serde_json::from_str(json_str).unwrap(); + match event { + ClaudeEvent::System(sys) => { + assert_eq!(sys.extra.get("custom_field").and_then(|v| v.as_str()), Some("custom_value")); + assert_eq!(sys.extra.get("another").and_then(|v| v.as_u64()), Some(42)); + } + _ => panic!("Expected System event"), + } + } + + // ── UsageInfo ───────────────────────────────────────────────── + + #[test] + fn usage_info_defaults_to_zero() { + let json_str = r#"{}"#; + let usage: UsageInfo = serde_json::from_str(json_str).unwrap(); + assert_eq!(usage.input_tokens, 0); + assert_eq!(usage.output_tokens, 0); + assert!(usage.cache_creation_input_tokens.is_none()); + assert!(usage.cache_read_input_tokens.is_none()); + } + + #[test] + fn usage_info_serializes_correctly() { + let usage = UsageInfo { + input_tokens: 100, + output_tokens: 50, + cache_creation_input_tokens: Some(10), + cache_read_input_tokens: None, + }; + let val = serde_json::to_value(&usage).unwrap(); + assert_eq!(val["input_tokens"], 100); + assert_eq!(val["output_tokens"], 50); + assert_eq!(val["cache_creation_input_tokens"], 10); + assert!(val["cache_read_input_tokens"].is_null()); + } + + // ── BridgeState ─────────────────────────────────────────────── + + #[test] + fn bridge_state_new_initializes_correctly() { + let state = BridgeState::new("ws_1".to_string(), "thread_1".to_string()); + assert_eq!(state.workspace_id, "ws_1"); + assert_eq!(state.thread_id, "thread_1"); + assert!(state.turn_id.starts_with("turn_")); + assert_eq!(state.next_item_id, 1); + assert!(state.block_items.is_empty()); + assert!(state.accumulated_text.is_empty()); + assert!(!state.thread_started); + assert!(!state.turn_started); + assert!(state.model.is_none()); + assert!(state.tool_items.is_empty()); + assert!(state.block_tool_use_ids.is_empty()); + assert_eq!(state.total_input_tokens, 0); + assert_eq!(state.total_output_tokens, 0); + assert!((state.total_cost_usd - 0.0).abs() < f64::EPSILON); + } + + #[test] + fn bridge_state_next_item_increments() { + let mut state = BridgeState::new("ws".to_string(), "t".to_string()); + assert_eq!(state.next_item(), "item_1"); + assert_eq!(state.next_item(), "item_2"); + assert_eq!(state.next_item(), "item_3"); + assert_eq!(state.next_item_id, 4); + } + + #[test] + fn bridge_state_new_turn_resets_per_turn_state() { + let mut state = BridgeState::new("ws".to_string(), "t".to_string()); + let original_turn_id = state.turn_id.clone(); + state.turn_started = true; + state.block_items.insert(0, "item_1".to_string()); + state.tool_items.insert("toolu_1".to_string(), super::ItemInfo { + item_id: "item_1".to_string(), + tool_use_id: "toolu_1".to_string(), + tool_name: "bash".to_string(), + category: ToolCategory::CommandExecution, + accumulated_input_json: String::new(), + aggregated_output: String::new(), + }); + state.block_tool_use_ids.insert(0, "toolu_1".to_string()); + + state.new_turn(); + + assert_ne!(state.turn_id, original_turn_id); + assert!(state.turn_id.starts_with("turn_")); + assert!(!state.turn_started); + assert!(state.block_items.is_empty()); + assert!(state.tool_items.is_empty()); + assert!(state.block_tool_use_ids.is_empty()); + } + + #[test] + fn bridge_state_new_turn_preserves_cumulative_state() { + let mut state = BridgeState::new("ws".to_string(), "t".to_string()); + state.total_input_tokens = 100; + state.total_output_tokens = 50; + state.total_cost_usd = 0.05; + state.accumulated_text = "some text".to_string(); + state.model = Some("claude-sonnet-4-20250514".to_string()); + state.thread_started = true; + // next_item_id should persist across turns + let _ = state.next_item(); // item_1 + let _ = state.next_item(); // item_2 + + state.new_turn(); + + assert_eq!(state.total_input_tokens, 100); + assert_eq!(state.total_output_tokens, 50); + assert!((state.total_cost_usd - 0.05).abs() < f64::EPSILON); + assert_eq!(state.accumulated_text, "some text"); + assert_eq!(state.model.as_deref(), Some("claude-sonnet-4-20250514")); + assert!(state.thread_started); + assert_eq!(state.next_item_id, 3); // preserved + } +} From 12a101b726202d1e7b2487e1564685555638a664 Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 08:21:56 +0000 Subject: [PATCH 09/16] feat: Phase 6 - Remote daemon mode support for Claude CLI bridge Route daemon session spawning through Claude CLI when backend_mode is set to Claude. Each DaemonState method resolves use_claude from app_settings before creating the spawn closure, then passes it to spawn_with_client which conditionally dispatches to spawn_claude_session or the default Codex spawn path. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src-tauri/src/bin/codex_monitor_daemon.rs | 43 ++++++++++++++++++----- 1 file changed, 35 insertions(+), 8 deletions(-) diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs index ede4a3df7..1d5a9b550 100644 --- a/src-tauri/src/bin/codex_monitor_daemon.rs +++ b/src-tauri/src/bin/codex_monitor_daemon.rs @@ -1,6 +1,9 @@ #[allow(dead_code)] #[path = "../backend/mod.rs"] mod backend; +#[allow(dead_code)] +#[path = "../claude_bridge/mod.rs"] +mod claude_bridge; #[path = "../codex/args.rs"] mod codex_args; #[path = "../codex/config.rs"] @@ -103,15 +106,23 @@ fn spawn_with_client( default_bin: Option, codex_args: Option, codex_home: Option, + use_claude: bool, ) -> impl std::future::Future, String>> { - spawn_workspace_session( - entry, - default_bin, - codex_args, - codex_home, - client_version, - event_sink, - ) + async move { + if use_claude { + claude_bridge::process::spawn_claude_session(entry, client_version, event_sink).await + } else { + spawn_workspace_session( + entry, + default_bin, + codex_args, + codex_home, + client_version, + event_sink, + ) + .await + } + } } #[derive(Clone)] @@ -253,6 +264,7 @@ impl DaemonState { client_version: String, ) -> Result { let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::add_workspace_core( path, &self.workspaces, @@ -267,6 +279,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -281,6 +294,7 @@ impl DaemonState { client_version: String, ) -> Result { let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::add_workspace_from_git_url_core( url, destination_path, @@ -297,6 +311,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -312,6 +327,7 @@ impl DaemonState { client_version: String, ) -> Result { let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::add_worktree_core( parent_id, branch, @@ -345,6 +361,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -413,6 +430,7 @@ impl DaemonState { client_version: String, ) -> Result { let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::rename_worktree_core( id, branch, @@ -446,6 +464,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -501,6 +520,7 @@ impl DaemonState { client_version: String, ) -> Result { let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::update_workspace_settings_core( id, settings, @@ -519,6 +539,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -534,6 +555,7 @@ impl DaemonState { } let client_version = client_version.clone(); + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::connect_workspace_core( id, &self.workspaces, @@ -547,6 +569,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) @@ -559,6 +582,7 @@ impl DaemonState { codex_args: Option, client_version: String, ) -> Result { + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::set_workspace_runtime_codex_args_core( workspace_id, codex_args, @@ -573,6 +597,7 @@ impl DaemonState { default_bin, next_args, codex_home, + use_claude, ) }, ) @@ -948,6 +973,7 @@ impl DaemonState { copy_name: String, client_version: String, ) -> Result { + let use_claude = self.app_settings.lock().await.backend_mode == types::BackendMode::Claude; workspaces_core::add_clone_core( source_workspace_id, copy_name, @@ -964,6 +990,7 @@ impl DaemonState { default_bin, codex_args, codex_home, + use_claude, ) }, ) From edbb70b23b6edf3ce3ca3db2d307f1990827f107 Mon Sep 17 00:00:00 2001 From: AndrewMoryakov Date: Thu, 5 Mar 2026 08:45:32 +0000 Subject: [PATCH 10/16] feat: UI backend mode badges and model brand colors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add visual indicators for the active backend mode (Codex/Claude/Remote) in both the sidebar workspace cards and the main header. Each mode gets a branded accent color badge: green for Codex, orange for Claude, blue for Remote. Also add brand-colored model badges on thread rows — Claude models show in Anthropic orange, GPT in purple, Gemini in blue, and Codex in green. https://claude.ai/code/session_0182kaMdjTV63jvU8bavh97C --- src/App.tsx | 1 + .../app/components/BackendModeBadge.tsx | 23 +++++++ src/features/app/components/MainHeader.tsx | 8 ++- src/features/app/components/Sidebar.test.tsx | 1 + src/features/app/components/Sidebar.tsx | 3 + src/features/app/components/ThreadRow.tsx | 12 +++- src/features/app/components/WorkspaceCard.tsx | 6 +- .../hooks/layoutNodes/buildPrimaryNodes.tsx | 2 + .../layout/hooks/layoutNodes/types.ts | 2 + src/styles/sidebar.css | 62 +++++++++++++++++++ 10 files changed, 117 insertions(+), 3 deletions(-) create mode 100644 src/features/app/components/BackendModeBadge.tsx diff --git a/src/App.tsx b/src/App.tsx index d96b7bac7..b506e77d0 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -2084,6 +2084,7 @@ function MainApp() { workspaces, groupedWorkspaces, hasWorkspaceGroups: workspaceGroups.length > 0, + backendMode: appSettings.backendMode, deletingWorktreeIds, newAgentDraftWorkspaceId, startingDraftThreadWorkspaceId, diff --git a/src/features/app/components/BackendModeBadge.tsx b/src/features/app/components/BackendModeBadge.tsx new file mode 100644 index 000000000..aabe5ceeb --- /dev/null +++ b/src/features/app/components/BackendModeBadge.tsx @@ -0,0 +1,23 @@ +import type { BackendMode } from "../../../types"; + +type BackendModeBadgeProps = { + mode: BackendMode; + className?: string; +}; + +const LABELS: Record = { + local: "Codex", + remote: "Remote", + claude: "Claude", +}; + +export function BackendModeBadge({ mode, className }: BackendModeBadgeProps) { + return ( + + {LABELS[mode]} + + ); +} diff --git a/src/features/app/components/MainHeader.tsx b/src/features/app/components/MainHeader.tsx index f8bce2506..0abf95d85 100644 --- a/src/features/app/components/MainHeader.tsx +++ b/src/features/app/components/MainHeader.tsx @@ -3,7 +3,7 @@ import Check from "lucide-react/dist/esm/icons/check"; import Copy from "lucide-react/dist/esm/icons/copy"; import Terminal from "lucide-react/dist/esm/icons/terminal"; import { revealItemInDir } from "@tauri-apps/plugin-opener"; -import type { BranchInfo, OpenAppTarget, WorkspaceInfo } from "../../../types"; +import type { BackendMode, BranchInfo, OpenAppTarget, WorkspaceInfo } from "../../../types"; import type { ReactNode } from "react"; import { revealInFileManagerLabel } from "../../../utils/platformPaths"; import { BranchList } from "../../git/components/BranchList"; @@ -13,6 +13,7 @@ import { MenuTrigger, PopoverSurface, } from "../../design-system/components/popover/PopoverPrimitives"; +import { BackendModeBadge } from "./BackendModeBadge"; import { OpenAppMenu } from "./OpenAppMenu"; import { LaunchScriptButton } from "./LaunchScriptButton"; import { LaunchScriptEntryButton } from "./LaunchScriptEntryButton"; @@ -21,6 +22,7 @@ import { useMenuController } from "../hooks/useMenuController"; type MainHeaderProps = { workspace: WorkspaceInfo; + backendMode?: BackendMode; parentName?: string | null; worktreeLabel?: string | null; disableBranchMenu?: boolean; @@ -74,6 +76,7 @@ type MainHeaderProps = { export function MainHeader({ workspace, + backendMode, parentName = null, worktreeLabel = null, disableBranchMenu = false, @@ -191,6 +194,9 @@ export function MainHeader({ {parentName ? parentName : workspace.name} + {backendMode && ( + + )} › diff --git a/src/features/app/components/Sidebar.test.tsx b/src/features/app/components/Sidebar.test.tsx index 893e447bb..fd539e7e2 100644 --- a/src/features/app/components/Sidebar.test.tsx +++ b/src/features/app/components/Sidebar.test.tsx @@ -68,6 +68,7 @@ const baseProps = { onWorkspaceDragEnter: vi.fn(), onWorkspaceDragLeave: vi.fn(), onWorkspaceDrop: vi.fn(), + backendMode: "local" as const, }; describe("Sidebar", () => { diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx index 53ce98a06..267486a55 100644 --- a/src/features/app/components/Sidebar.tsx +++ b/src/features/app/components/Sidebar.tsx @@ -115,6 +115,7 @@ type SidebarProps = { onWorkspaceDragEnter: (event: React.DragEvent) => void; onWorkspaceDragLeave: (event: React.DragEvent) => void; onWorkspaceDrop: (event: React.DragEvent) => void; + backendMode: import("../../../types").BackendMode; }; export const Sidebar = memo(function Sidebar({ @@ -176,6 +177,7 @@ export const Sidebar = memo(function Sidebar({ onWorkspaceDragEnter, onWorkspaceDragLeave, onWorkspaceDrop, + backendMode, }: SidebarProps) { const [expandedWorkspaces, setExpandedWorkspaces] = useState( new Set(), @@ -1002,6 +1004,7 @@ export const Sidebar = memo(function Sidebar({ key={entry.id} workspace={entry} workspaceName={renderHighlightedName(entry.name)} + backendMode={backendMode} isActive={entry.id === activeWorkspaceId} isCollapsed={isCollapsed} addMenuOpen={addMenuOpen} diff --git a/src/features/app/components/ThreadRow.tsx b/src/features/app/components/ThreadRow.tsx index 008b61ef8..86452e5d5 100644 --- a/src/features/app/components/ThreadRow.tsx +++ b/src/features/app/components/ThreadRow.tsx @@ -3,6 +3,16 @@ import type { CSSProperties, MouseEvent } from "react"; import type { ThreadSummary } from "../../../types"; import { getThreadStatusClass, type ThreadStatusById } from "../../../utils/threadStatus"; +function modelBrandClass(modelId: string | null | undefined): string { + if (!modelId) return ""; + const lower = modelId.toLowerCase(); + if (lower.includes("claude") || lower.includes("anthropic")) return " model-claude"; + if (lower.includes("gpt") || lower.includes("openai")) return " model-gpt"; + if (lower.includes("gemini") || lower.includes("google")) return " model-gemini"; + if (lower.includes("codex")) return " model-codex"; + return ""; +} + type ThreadRowProps = { thread: ThreadSummary; depth: number; @@ -95,7 +105,7 @@ export function ThreadRow({
{workspaceLabel && {workspaceLabel}} {modelBadge && ( - + {modelBadge} )} diff --git a/src/features/app/components/WorkspaceCard.tsx b/src/features/app/components/WorkspaceCard.tsx index 670384ae4..df8cef750 100644 --- a/src/features/app/components/WorkspaceCard.tsx +++ b/src/features/app/components/WorkspaceCard.tsx @@ -1,10 +1,12 @@ import type { MouseEvent } from "react"; -import type { WorkspaceInfo } from "../../../types"; +import type { BackendMode, WorkspaceInfo } from "../../../types"; +import { BackendModeBadge } from "./BackendModeBadge"; type WorkspaceCardProps = { workspace: WorkspaceInfo; workspaceName?: React.ReactNode; + backendMode?: BackendMode; isActive: boolean; isCollapsed: boolean; addMenuOpen: boolean; @@ -25,6 +27,7 @@ type WorkspaceCardProps = { export function WorkspaceCard({ workspace, workspaceName, + backendMode, isActive, isCollapsed, addMenuOpen, @@ -57,6 +60,7 @@ export function WorkspaceCard({
{workspaceName ?? workspace.name} + {backendMode && }