diff --git a/apps/backend/go.mod b/apps/backend/go.mod
index 20cfb6508e..ad4fbd5944 100644
--- a/apps/backend/go.mod
+++ b/apps/backend/go.mod
@@ -10,7 +10,6 @@ require (
github.com/docker/go-connections v0.6.0
github.com/fsnotify/fsnotify v1.6.0
github.com/gin-gonic/gin v1.9.1
- github.com/github/copilot-sdk/go v0.1.18
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3
github.com/jackc/pgx/v5 v5.9.0
@@ -61,7 +60,6 @@ require (
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.14.0 // indirect
github.com/goccy/go-json v0.10.2 // indirect
- github.com/google/jsonschema-go v0.4.2 // indirect
github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 // indirect
github.com/hashicorp/hcl v1.0.0 // indirect
github.com/invopop/jsonschema v0.13.0 // indirect
diff --git a/apps/backend/go.sum b/apps/backend/go.sum
index 41dbf8b8a9..853170460c 100644
--- a/apps/backend/go.sum
+++ b/apps/backend/go.sum
@@ -109,8 +109,6 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE
github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
-github.com/github/copilot-sdk/go v0.1.18 h1:S1ocOfTKxiNGtj+/qp4z+RZeOr9hniqy3UqIIYZxsuQ=
-github.com/github/copilot-sdk/go v0.1.18/go.mod h1:0SYT+64k347IDT0Trn4JHVFlUhPtGSE6ab479tU/+tY=
github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -172,8 +170,6 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/jsonschema-go v0.4.2 h1:tmrUohrwoLZZS/P3x7ex0WAVknEkBZM46iALbcqoRA8=
-github.com/google/jsonschema-go v0.4.2/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
diff --git a/apps/backend/pkg/amp/client.go b/apps/backend/pkg/amp/client.go
deleted file mode 100644
index 70a87e1e2b..0000000000
--- a/apps/backend/pkg/amp/client.go
+++ /dev/null
@@ -1,306 +0,0 @@
-// Package amp provides a client wrapper for the Sourcegraph Amp CLI.
-// This package handles communication with the Amp CLI via stream-json protocol.
-package amp
-
-import (
- "bufio"
- "context"
- "encoding/json"
- "fmt"
- "io"
- "sync"
-
- "github.com/kandev/kandev/internal/common/logger"
- "go.uber.org/zap"
-)
-
-// Message types for Amp stream-json protocol.
-// Amp claims Claude Code compatibility via --stream-json, so these match Claude Code's types.
-const (
- MessageTypeSystem = "system"
- MessageTypeAssistant = "assistant"
- MessageTypeResult = "result"
- MessageTypeUser = "user"
- MessageTypeRateLimit = "rate_limit_event"
-)
-
-// Content block types.
-const (
- ContentTypeText = "text"
- ContentTypeThinking = "thinking"
- ContentTypeToolUse = "tool_use"
- ContentTypeToolResult = "tool_result"
-)
-
-// Client wraps communication with Amp CLI via stdin/stdout.
-type Client struct {
- stdin io.Writer
- stdout io.Reader
- logger *logger.Logger
-
- scanner *bufio.Scanner
-
- // Message handler
- messageHandler func(*Message)
- handlerMu sync.RWMutex
-
- // Context for lifecycle
- ctx context.Context
- cancel context.CancelFunc
- wg sync.WaitGroup
-
- // State
- threadID string
- mu sync.RWMutex
-}
-
-// Message represents a message from Amp.
-// Amp uses Claude Code-compatible stream-json format, so fields match both protocols.
-type Message struct {
- Type string `json:"type"`
- ThreadID string `json:"thread_id,omitempty"`
- Message *Content `json:"message,omitempty"`
- ParentToolUseID string `json:"parent_tool_use_id,omitempty"`
-
- // Result fields (when Type == "result")
- IsError bool `json:"is_error,omitempty"`
- Error string `json:"error,omitempty"` // Single error message
- Errors []string `json:"errors,omitempty"` // Multiple errors (Claude Code format)
- Subtype string `json:"subtype,omitempty"` // e.g., "error_during_execution"
- CostUSD float64 `json:"cost_usd,omitempty"`
- TotalCostUSD float64 `json:"total_cost_usd,omitempty"` // Claude Code uses this field name
- DurationMS int64 `json:"duration_ms,omitempty"`
- NumTurns int `json:"num_turns,omitempty"`
- TotalInputTokens int64 `json:"total_input_tokens,omitempty"`
- TotalOutputTokens int64 `json:"total_output_tokens,omitempty"`
- Result json.RawMessage `json:"result,omitempty"`
- ModelUsage map[string]*Usage `json:"model_usage,omitempty"`
-
- // Rate limit fields (when Type == "rate_limit_event")
- RateLimitInfo json.RawMessage `json:"rate_limit_info,omitempty"`
-}
-
-// GetCostUSD returns the cost, checking both total_cost_usd (Claude Code format)
-// and cost_usd (Amp format).
-func (m *Message) GetCostUSD() float64 {
- if m.TotalCostUSD != 0 {
- return m.TotalCostUSD
- }
- return m.CostUSD
-}
-
-// Content represents the message content.
-type Content struct {
- Model string `json:"model,omitempty"`
- Content []ContentBlock `json:"content,omitempty"`
- Usage *TokenUsage `json:"usage,omitempty"`
- StopReason string `json:"stop_reason,omitempty"`
- StopSequence string `json:"stop_sequence,omitempty"`
-}
-
-// ContentBlock represents a content block (text, tool_use, etc.).
-type ContentBlock struct {
- Type string `json:"type"`
- Text string `json:"text,omitempty"`
- Thinking string `json:"thinking,omitempty"`
- ID string `json:"id,omitempty"`
- Name string `json:"name,omitempty"`
- Input map[string]any `json:"input,omitempty"`
- ToolUseID string `json:"tool_use_id,omitempty"`
- Content any `json:"content,omitempty"`
- IsError bool `json:"is_error,omitempty"`
-}
-
-// TokenUsage represents token usage information.
-type TokenUsage struct {
- InputTokens int64 `json:"input_tokens,omitempty"`
- OutputTokens int64 `json:"output_tokens,omitempty"`
- CacheCreationInputTokens int64 `json:"cache_creation_input_tokens,omitempty"`
- CacheReadInputTokens int64 `json:"cache_read_input_tokens,omitempty"`
-}
-
-// Usage represents model-specific usage stats.
-type Usage struct {
- InputTokens int64 `json:"input_tokens,omitempty"`
- OutputTokens int64 `json:"output_tokens,omitempty"`
- ContextWindow *int64 `json:"context_window,omitempty"`
-}
-
-// ResultData represents the result data structure.
-type ResultData struct {
- SessionID string `json:"session_id,omitempty"`
- ThreadID string `json:"thread_id,omitempty"`
- Text string `json:"text,omitempty"`
-}
-
-// UserMessage represents a user message to send (Claude Code-compatible format).
-type UserMessage struct {
- Type string `json:"type"` // "user"
- Message UserMessageBody `json:"message"`
-}
-
-// UserMessageBody is the nested message body for user messages.
-type UserMessageBody struct {
- Role string `json:"role"` // "user"
- Content []UserContentBlock `json:"content"`
-}
-
-// UserContentBlock represents a content block in user messages.
-type UserContentBlock struct {
- Type string `json:"type"` // "text"
- Text string `json:"text"`
-}
-
-// NewClient creates a new Amp client.
-func NewClient(stdin io.Writer, stdout io.Reader, log *logger.Logger) *Client {
- ctx, cancel := context.WithCancel(context.Background())
- return &Client{
- stdin: stdin,
- stdout: stdout,
- logger: log.WithFields(zap.String("component", "amp-client")),
- ctx: ctx,
- cancel: cancel,
- }
-}
-
-// SetMessageHandler sets the handler for incoming messages.
-func (c *Client) SetMessageHandler(handler func(*Message)) {
- c.handlerMu.Lock()
- defer c.handlerMu.Unlock()
- c.messageHandler = handler
-}
-
-// Start begins reading from stdout and dispatching messages.
-func (c *Client) Start(ctx context.Context) {
- c.scanner = bufio.NewScanner(c.stdout)
- // Allow larger buffer for JSON messages
- c.scanner.Buffer(make([]byte, 64*1024), 1024*1024)
-
- c.wg.Add(1)
- go c.readLoop(ctx)
-}
-
-// Stop stops the client and waits for goroutines to finish.
-func (c *Client) Stop() {
- c.cancel()
- c.wg.Wait()
-}
-
-// readLoop reads JSON lines from stdout and dispatches them.
-func (c *Client) readLoop(ctx context.Context) {
- defer c.wg.Done()
-
- for {
- select {
- case <-ctx.Done():
- return
- case <-c.ctx.Done():
- return
- default:
- }
-
- if !c.scanner.Scan() {
- if err := c.scanner.Err(); err != nil {
- c.logger.Error("scanner error", zap.Error(err))
- }
- return
- }
-
- line := c.scanner.Text()
- if line == "" {
- continue
- }
-
- c.handleLine(line)
- }
-}
-
-// handleLine parses and dispatches a JSON line.
-func (c *Client) handleLine(line string) {
- var msg Message
- if err := json.Unmarshal([]byte(line), &msg); err != nil {
- c.logger.Debug("failed to parse message", zap.Error(err), zap.String("line", line))
- return
- }
-
- // Update thread ID if provided
- if msg.ThreadID != "" {
- c.mu.Lock()
- c.threadID = msg.ThreadID
- c.mu.Unlock()
- }
-
- c.handlerMu.RLock()
- handler := c.messageHandler
- c.handlerMu.RUnlock()
-
- if handler != nil {
- handler(&msg)
- }
-}
-
-// SendUserMessage sends a user message to Amp.
-func (c *Client) SendUserMessage(message string) error {
- msg := &UserMessage{
- Type: "user",
- Message: UserMessageBody{
- Role: "user",
- Content: []UserContentBlock{
- {Type: "text", Text: message},
- },
- },
- }
-
- data, err := json.Marshal(msg)
- if err != nil {
- return fmt.Errorf("failed to marshal message: %w", err)
- }
-
- if _, err := c.stdin.Write(append(data, '\n')); err != nil {
- return fmt.Errorf("failed to write message: %w", err)
- }
-
- return nil
-}
-
-// GetThreadID returns the current thread ID.
-func (c *Client) GetThreadID() string {
- c.mu.RLock()
- defer c.mu.RUnlock()
- return c.threadID
-}
-
-// SetThreadID sets the current thread ID.
-func (c *Client) SetThreadID(threadID string) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.threadID = threadID
-}
-
-// GetResultData extracts ResultData from a result message.
-func (m *Message) GetResultData() *ResultData {
- if len(m.Result) == 0 {
- return nil
- }
-
- var data ResultData
- if err := json.Unmarshal(m.Result, &data); err != nil {
- return nil
- }
-
- return &data
-}
-
-// GetResultString extracts a string result (for error messages).
-func (m *Message) GetResultString() string {
- if len(m.Result) == 0 {
- return ""
- }
-
- var s string
- if err := json.Unmarshal(m.Result, &s); err != nil {
- return ""
- }
-
- return s
-}
diff --git a/apps/backend/pkg/claudecode/client.go b/apps/backend/pkg/claudecode/client.go
deleted file mode 100644
index ec3adf8d59..0000000000
--- a/apps/backend/pkg/claudecode/client.go
+++ /dev/null
@@ -1,353 +0,0 @@
-package claudecode
-
-import (
- "bufio"
- "context"
- "encoding/json"
- "fmt"
- "io"
- "sync"
- "time"
-
- "github.com/google/uuid"
- "github.com/kandev/kandev/internal/common/logger"
- "go.uber.org/zap"
-)
-
-// RequestHandler handles incoming control requests from Claude Code CLI.
-// It receives the request ID and control request, and should call SendControlResponse.
-type RequestHandler func(requestID string, req *ControlRequest)
-
-// CancelHandler handles control_cancel_request messages that cancel a pending request.
-type CancelHandler func(requestID string)
-
-// MessageHandler handles streaming messages from Claude Code CLI.
-type MessageHandler func(msg *CLIMessage)
-
-// pendingRequest tracks a control request waiting for a response.
-type pendingRequest struct {
- ch chan *IncomingControlResponse
-}
-
-// Client handles Claude Code CLI communication over stdin/stdout streams.
-// It reads streaming JSON from stdout and writes control messages to stdin.
-type Client struct {
- stdin io.Writer
- stdout io.Reader
- logger *logger.Logger
-
- // Handlers for incoming messages
- requestHandler RequestHandler
- cancelHandler CancelHandler
- messageHandler MessageHandler
- closeHandler func() // Called when readLoop exits (EOF or error)
-
- // Pending control requests (requests we sent, waiting for responses)
- pendingRequests map[string]*pendingRequest
- pendingRequestsMu sync.Mutex
-
- // Synchronization
- mu sync.RWMutex
- done chan struct{}
-}
-
-// NewClient creates a new Claude Code CLI client.
-func NewClient(stdin io.Writer, stdout io.Reader, log *logger.Logger) *Client {
- return &Client{
- stdin: stdin,
- stdout: stdout,
- logger: log.WithFields(zap.String("component", "claudecode-client")),
- done: make(chan struct{}),
- pendingRequests: make(map[string]*pendingRequest),
- }
-}
-
-// SetRequestHandler sets the handler for incoming control requests.
-func (c *Client) SetRequestHandler(handler RequestHandler) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.requestHandler = handler
-}
-
-// SetCancelHandler sets the handler for control_cancel_request messages.
-func (c *Client) SetCancelHandler(handler CancelHandler) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.cancelHandler = handler
-}
-
-// SetMessageHandler sets the handler for streaming messages.
-func (c *Client) SetMessageHandler(handler MessageHandler) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.messageHandler = handler
-}
-
-// SetCloseHandler sets a handler called when the read loop exits (EOF or error).
-func (c *Client) SetCloseHandler(handler func()) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.closeHandler = handler
-}
-
-// Start begins reading from stdout in a goroutine.
-// Returns a channel that is closed when the read loop is ready.
-func (c *Client) Start(ctx context.Context) <-chan struct{} {
- ready := make(chan struct{})
- go c.readLoop(ctx, ready)
- return ready
-}
-
-// Stop stops the client and closes the done channel.
-func (c *Client) Stop() {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- select {
- case <-c.done:
- // Already closed
- default:
- close(c.done)
- }
-}
-
-// Initialize sends the initialize control request to Claude Code CLI and waits for the response.
-// This must be called in streaming mode (input-format=stream-json) to get slash commands.
-// hooks is optional — pass nil for no hooks.
-func (c *Client) Initialize(ctx context.Context, timeout time.Duration, hooks map[string]any) (*InitializeResponseData, error) {
- requestID := uuid.New().String()
-
- // Create pending request channel
- pending := &pendingRequest{
- ch: make(chan *IncomingControlResponse, 1),
- }
-
- c.pendingRequestsMu.Lock()
- c.pendingRequests[requestID] = pending
- c.pendingRequestsMu.Unlock()
-
- defer func() {
- c.pendingRequestsMu.Lock()
- delete(c.pendingRequests, requestID)
- c.pendingRequestsMu.Unlock()
- }()
-
- // Send initialize control request
- req := &SDKControlRequest{
- Type: MessageTypeControlRequest,
- RequestID: requestID,
- Request: SDKControlRequestBody{
- Subtype: SubtypeInitialize,
- Hooks: hooks,
- },
- }
-
- c.logger.Info("sending initialize control request", zap.String("request_id", requestID))
-
- if err := c.send(req); err != nil {
- return nil, fmt.Errorf("failed to send initialize request: %w", err)
- }
-
- // Wait for response with timeout
- c.logger.Info("waiting for initialize response", zap.Duration("timeout", timeout))
- select {
- case <-ctx.Done():
- c.logger.Warn("initialize cancelled by context")
- return nil, ctx.Err()
- case <-time.After(timeout):
- c.logger.Warn("initialize request timed out", zap.Duration("timeout", timeout))
- return nil, fmt.Errorf("initialize request timed out after %v", timeout)
- case resp := <-pending.ch:
- if resp.Subtype == "error" {
- return nil, fmt.Errorf("initialize failed: %s", resp.Error)
- }
- c.logger.Info("initialize response received",
- zap.Int("commands", len(resp.Response.Commands)),
- zap.Int("agents", len(resp.Response.Agents)))
- return resp.Response, nil
- }
-}
-
-// SendControlRequest sends a control request to Claude Code CLI.
-func (c *Client) SendControlRequest(req *SDKControlRequest) error {
- return c.send(req)
-}
-
-// SendControlResponse sends a control response to Claude Code CLI.
-func (c *Client) SendControlResponse(resp *ControlResponseMessage) error {
- return c.send(resp)
-}
-
-// SendUserMessage sends a user message (prompt) to Claude Code CLI.
-func (c *Client) SendUserMessage(content string) error {
- msg := &UserMessage{
- Type: MessageTypeUser,
- Message: UserMessageBody{
- Role: "user",
- Content: content,
- },
- }
- return c.send(msg)
-}
-
-func (c *Client) send(msg any) error {
- data, err := json.Marshal(msg)
- if err != nil {
- return fmt.Errorf("failed to marshal message: %w", err)
- }
- data = append(data, '\n')
- _, err = c.stdin.Write(data)
- if err != nil {
- return fmt.Errorf("failed to write message: %w", err)
- }
- c.logger.Debug("claudecode: sent message", zap.String("data", string(data)))
- return nil
-}
-
-func (c *Client) readLoop(ctx context.Context, ready chan<- struct{}) {
- scanner := bufio.NewScanner(c.stdout)
- // Allow for large JSON messages (up to 10MB)
- buf := make([]byte, 0, 64*1024)
- scanner.Buffer(buf, 10*1024*1024)
-
- // Signal that we're ready to read
- c.logger.Info("claudecode: read loop starting")
- close(ready)
-
- for scanner.Scan() {
- select {
- case <-ctx.Done():
- return
- case <-c.done:
- return
- default:
- }
-
- line := scanner.Bytes()
- if len(line) == 0 {
- continue
- }
-
- c.handleLine(line)
- }
-
- if err := scanner.Err(); err != nil {
- c.logger.Error("read loop error", zap.Error(err))
- }
-
- // Notify close handler (e.g., to unblock Prompt on unexpected EOF)
- c.mu.RLock()
- handler := c.closeHandler
- c.mu.RUnlock()
- if handler != nil {
- handler()
- }
-}
-
-func (c *Client) handleLine(line []byte) {
- // Log all incoming lines for debugging
- c.logger.Debug("claudecode: received raw line",
- zap.String("line", string(line)))
-
- // First, parse the basic structure to determine message type
- var msg CLIMessage
- if err := json.Unmarshal(line, &msg); err != nil {
- c.logger.Warn("failed to parse message", zap.Error(err), zap.String("line", string(line)))
- return
- }
-
- c.logger.Debug("claudecode: parsed message",
- zap.String("type", msg.Type),
- zap.String("request_id", msg.RequestID),
- zap.Bool("has_response", msg.Response != nil))
-
- // Handle control requests (from Claude to us, e.g., permission requests)
- if msg.Type == MessageTypeControlRequest && msg.Request != nil {
- c.handleControlRequest(msg.RequestID, msg.Request)
- return
- }
-
- // Handle control_cancel_request (cancels a pending permission/hook request)
- if msg.Type == MessageTypeControlCancelRequest && msg.RequestID != "" {
- c.mu.RLock()
- handler := c.cancelHandler
- c.mu.RUnlock()
-
- if handler != nil {
- handler(msg.RequestID)
- } else {
- c.logger.Warn("received control_cancel_request but no cancel handler registered",
- zap.String("request_id", msg.RequestID))
- }
- return
- }
-
- // Handle control responses (from Claude back to us, e.g., initialize response)
- // Note: request_id is inside the response object, not at the message level
- if msg.Type == MessageTypeControlResponse && msg.Response != nil {
- c.handleControlResponse(msg.Response)
- return
- }
-
- // Forward other messages to the message handler
- c.mu.RLock()
- handler := c.messageHandler
- c.mu.RUnlock()
-
- if handler != nil {
- // Store raw line for advanced parsing if needed
- msg.RawContent = line
- handler(&msg)
- }
-}
-
-func (c *Client) handleControlRequest(requestID string, req *ControlRequest) {
- c.mu.RLock()
- handler := c.requestHandler
- c.mu.RUnlock()
-
- if handler != nil {
- handler(requestID, req)
- } else {
- c.logger.Warn("received control request but no handler registered",
- zap.String("request_id", requestID),
- zap.String("subtype", req.Subtype))
- // Auto-deny if no handler
- if err := c.SendControlResponse(&ControlResponseMessage{
- Type: MessageTypeControlResponse,
- RequestID: requestID,
- Response: &ControlResponse{
- Subtype: "error",
- Error: "no handler registered",
- },
- }); err != nil {
- c.logger.Warn("failed to send error response", zap.Error(err))
- }
- }
-}
-
-func (c *Client) handleControlResponse(resp *IncomingControlResponse) {
- requestID := resp.RequestID
-
- c.pendingRequestsMu.Lock()
- pending, ok := c.pendingRequests[requestID]
- c.pendingRequestsMu.Unlock()
-
- if !ok {
- c.logger.Warn("received control response for unknown request",
- zap.String("request_id", requestID),
- zap.String("subtype", resp.Subtype))
- return
- }
-
- c.logger.Info("received control response",
- zap.String("request_id", requestID),
- zap.String("subtype", resp.Subtype))
-
- // Send response to waiting goroutine
- select {
- case pending.ch <- resp:
- default:
- c.logger.Warn("pending request channel full", zap.String("request_id", requestID))
- }
-}
diff --git a/apps/backend/pkg/claudecode/client_test.go b/apps/backend/pkg/claudecode/client_test.go
deleted file mode 100644
index 39cbb76362..0000000000
--- a/apps/backend/pkg/claudecode/client_test.go
+++ /dev/null
@@ -1,484 +0,0 @@
-package claudecode
-
-import (
- "bytes"
- "context"
- "encoding/json"
- "io"
- "strings"
- "sync"
- "testing"
- "time"
-
- "github.com/kandev/kandev/internal/common/logger"
-)
-
-// syncBuffer is a thread-safe bytes.Buffer for tests where a goroutine writes
-// and the test goroutine reads.
-type syncBuffer struct {
- mu sync.Mutex
- buf bytes.Buffer
-}
-
-func (sb *syncBuffer) Write(p []byte) (int, error) {
- sb.mu.Lock()
- defer sb.mu.Unlock()
- return sb.buf.Write(p)
-}
-
-func (sb *syncBuffer) Len() int {
- sb.mu.Lock()
- defer sb.mu.Unlock()
- return sb.buf.Len()
-}
-
-func (sb *syncBuffer) Bytes() []byte {
- sb.mu.Lock()
- defer sb.mu.Unlock()
- return append([]byte(nil), sb.buf.Bytes()...)
-}
-
-func newTestLogger() *logger.Logger {
- log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
- return log
-}
-
-func TestClient_SendUserMessage(t *testing.T) {
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(""), newTestLogger())
-
- err := client.SendUserMessage("Hello, Claude!")
- if err != nil {
- t.Fatalf("SendUserMessage() error = %v", err)
- }
-
- // Parse what was written
- var msg UserMessage
- if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &msg); err != nil {
- t.Fatalf("failed to parse sent message: %v", err)
- }
-
- if msg.Type != MessageTypeUser {
- t.Errorf("Type = %q, want %q", msg.Type, MessageTypeUser)
- }
- if msg.Message.Role != "user" {
- t.Errorf("Message.Role = %q, want %q", msg.Message.Role, "user")
- }
- if msg.Message.Content != "Hello, Claude!" {
- t.Errorf("Message.Content = %q, want %q", msg.Message.Content, "Hello, Claude!")
- }
-}
-
-func TestClient_SendControlResponse(t *testing.T) {
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(""), newTestLogger())
-
- resp := &ControlResponseMessage{
- Type: MessageTypeControlResponse,
- RequestID: "req123",
- Response: &ControlResponse{
- Subtype: "success",
- Result: &PermissionResult{
- Behavior: BehaviorAllow,
- },
- },
- }
-
- err := client.SendControlResponse(resp)
- if err != nil {
- t.Fatalf("SendControlResponse() error = %v", err)
- }
-
- // Parse what was written
- var parsed ControlResponseMessage
- if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &parsed); err != nil {
- t.Fatalf("failed to parse sent message: %v", err)
- }
-
- if parsed.RequestID != "req123" {
- t.Errorf("RequestID = %q, want %q", parsed.RequestID, "req123")
- }
-}
-
-func TestClient_SendControlRequest(t *testing.T) {
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(""), newTestLogger())
-
- req := &SDKControlRequest{
- Type: MessageTypeControlRequest,
- RequestID: "init123",
- Request: SDKControlRequestBody{
- Subtype: SubtypeInitialize,
- },
- }
-
- err := client.SendControlRequest(req)
- if err != nil {
- t.Fatalf("SendControlRequest() error = %v", err)
- }
-
- // Parse what was written
- var parsed SDKControlRequest
- if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &parsed); err != nil {
- t.Fatalf("failed to parse sent message: %v", err)
- }
-
- if parsed.Request.Subtype != SubtypeInitialize {
- t.Errorf("Request.Subtype = %q, want %q", parsed.Request.Subtype, SubtypeInitialize)
- }
-}
-
-func TestClient_HandleMessages(t *testing.T) {
- // Create input with multiple messages
- messages := []string{
- `{"type":"system","session_id":"sess123"}`,
- `{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Hello"}]}}`,
- }
- input := strings.Join(messages, "\n") + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var received []CLIMessage
- var mu sync.Mutex
- client.SetMessageHandler(func(msg *CLIMessage) {
- mu.Lock()
- received = append(received, *msg)
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond) // Give time for processing
-
- mu.Lock()
- count := len(received)
- mu.Unlock()
-
- if count != 2 {
- t.Errorf("received %d messages, want 2", count)
- }
-}
-
-func TestClient_HandleControlRequest(t *testing.T) {
- // Create a control request message
- input := `{"type":"control_request","request_id":"req123","request":{"subtype":"can_use_tool","tool_name":"Bash"}}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var receivedReq *ControlRequest
- var receivedID string
- var mu sync.Mutex
-
- client.SetRequestHandler(func(requestID string, req *ControlRequest) {
- mu.Lock()
- receivedID = requestID
- receivedReq = req
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond) // Give time for processing
-
- mu.Lock()
- defer mu.Unlock()
-
- if receivedID != "req123" {
- t.Errorf("requestID = %q, want %q", receivedID, "req123")
- }
- if receivedReq == nil {
- t.Fatal("receivedReq is nil")
- }
- if receivedReq.Subtype != SubtypeCanUseTool {
- t.Errorf("Subtype = %q, want %q", receivedReq.Subtype, SubtypeCanUseTool)
- }
-}
-
-func TestClient_Stop(t *testing.T) {
- // Use a pipe for continuous input
- pr, _ := io.Pipe()
-
- var buf bytes.Buffer
- client := NewClient(&buf, pr, newTestLogger())
-
- ctx := context.Background()
- client.Start(ctx)
-
- // Stop should not panic even if called multiple times
- client.Stop()
- client.Stop()
-}
-
-func TestClient_NoHandlerAutoReject(t *testing.T) {
- // Create a control request message
- input := `{"type":"control_request","request_id":"req123","request":{"subtype":"can_use_tool","tool_name":"Bash"}}` + "\n"
-
- buf := &syncBuffer{}
- client := NewClient(buf, strings.NewReader(input), newTestLogger())
-
- // No request handler set - should auto-reject
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond) // Give time for processing
-
- // Should have sent an error response
- if buf.Len() == 0 {
- t.Error("expected error response to be sent")
- }
-
- var resp ControlResponseMessage
- if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &resp); err != nil {
- t.Fatalf("failed to parse response: %v", err)
- }
-
- if resp.Response == nil || resp.Response.Subtype != "error" {
- t.Error("expected error response")
- }
-}
-
-func TestClient_EmptyLines(t *testing.T) {
- // Test that empty lines are skipped
- input := "\n\n{\"type\":\"system\",\"session_id\":\"abc\"}\n\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var count int
- var mu sync.Mutex
- client.SetMessageHandler(func(msg *CLIMessage) {
- mu.Lock()
- count++
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- mu.Lock()
- defer mu.Unlock()
-
- if count != 1 {
- t.Errorf("count = %d, want 1", count)
- }
-}
-
-func TestClient_InvalidJSON(t *testing.T) {
- // Test that invalid JSON is handled gracefully
- input := "{invalid json}\n{\"type\":\"system\"}\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var count int
- var mu sync.Mutex
- client.SetMessageHandler(func(msg *CLIMessage) {
- mu.Lock()
- count++
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- mu.Lock()
- defer mu.Unlock()
-
- // Should still process the valid message
- if count != 1 {
- t.Errorf("count = %d, want 1", count)
- }
-}
-
-func TestClient_HandleControlResponse(t *testing.T) {
- // Simulate a control response coming back from Claude Code CLI
- responseJSON := `{"type":"control_response","response":{"subtype":"success","request_id":"test-req-123","response":{"commands":[{"name":"cost","description":"Show cost"}],"agents":["Bash"]}}}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(responseJSON), newTestLogger())
-
- // Register a pending request
- pending := &pendingRequest{
- ch: make(chan *IncomingControlResponse, 1),
- }
- client.pendingRequestsMu.Lock()
- client.pendingRequests["test-req-123"] = pending
- client.pendingRequestsMu.Unlock()
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
-
- // Wait for the response
- select {
- case resp := <-pending.ch:
- if resp.Subtype != "success" {
- t.Errorf("Subtype = %q, want %q", resp.Subtype, "success")
- }
- if resp.RequestID != "test-req-123" {
- t.Errorf("RequestID = %q, want %q", resp.RequestID, "test-req-123")
- }
- if resp.Response == nil {
- t.Fatal("Response is nil")
- }
- if len(resp.Response.Commands) != 1 {
- t.Errorf("Commands count = %d, want %d", len(resp.Response.Commands), 1)
- }
- if resp.Response.Commands[0].Name != "cost" {
- t.Errorf("Commands[0].Name = %q, want %q", resp.Response.Commands[0].Name, "cost")
- }
- case <-time.After(50 * time.Millisecond):
- t.Error("timeout waiting for control response")
- }
-}
-
-func TestClient_HandleControlResponse_UnknownRequest(t *testing.T) {
- // Simulate a control response for an unknown request ID (should be ignored)
- responseJSON := `{"type":"control_response","response":{"subtype":"success","request_id":"unknown-req","response":{"commands":[]}}}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(responseJSON), newTestLogger())
-
- // Don't register any pending request - response should be ignored
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- // Test passes if no panic occurs - the unknown response is just logged and ignored
-}
-
-func TestClient_HandleControlCancelRequest(t *testing.T) {
- input := `{"type":"control_cancel_request","request_id":"cancel-req-123"}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var receivedID string
- var mu sync.Mutex
-
- client.SetCancelHandler(func(requestID string) {
- mu.Lock()
- receivedID = requestID
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- mu.Lock()
- defer mu.Unlock()
-
- if receivedID != "cancel-req-123" {
- t.Errorf("cancel handler received ID = %q, want %q", receivedID, "cancel-req-123")
- }
-}
-
-func TestClient_HandleControlCancelRequest_NoHandler(t *testing.T) {
- // Without a cancel handler, the cancel request should be logged and ignored
- input := `{"type":"control_cancel_request","request_id":"cancel-req-456"}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- // Don't register a cancel handler
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- // Test passes if no panic occurs
-}
-
-func TestClient_CloseHandler_CalledOnEOF(t *testing.T) {
- // Reader that immediately returns EOF
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(""), newTestLogger())
-
- var called bool
- var mu sync.Mutex
- client.SetCloseHandler(func() {
- mu.Lock()
- called = true
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(100 * time.Millisecond) // Give time for readLoop to exit
-
- mu.Lock()
- defer mu.Unlock()
- if !called {
- t.Error("close handler was not called on EOF")
- }
-}
-
-func TestClient_CloseHandler_NotSetNoPanic(t *testing.T) {
- // Verify no panic when close handler is not set
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(""), newTestLogger())
-
- ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(100 * time.Millisecond)
-
- // Test passes if no panic occurs
-}
-
-func TestClient_HandleControlCancelRequest_NotForwardedAsMessage(t *testing.T) {
- // control_cancel_request should be handled by the cancel handler,
- // not forwarded to the message handler
- input := `{"type":"control_cancel_request","request_id":"cancel-req-789"}` + "\n"
-
- var buf bytes.Buffer
- client := NewClient(&buf, strings.NewReader(input), newTestLogger())
-
- var messageCount int
- var mu sync.Mutex
-
- client.SetCancelHandler(func(requestID string) {})
- client.SetMessageHandler(func(msg *CLIMessage) {
- mu.Lock()
- messageCount++
- mu.Unlock()
- })
-
- ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
- defer cancel()
-
- client.Start(ctx)
- time.Sleep(50 * time.Millisecond)
-
- mu.Lock()
- defer mu.Unlock()
-
- if messageCount != 0 {
- t.Errorf("message handler received %d messages, want 0", messageCount)
- }
-}
diff --git a/apps/backend/pkg/claudecode/types.go b/apps/backend/pkg/claudecode/types.go
deleted file mode 100644
index 1987e63c69..0000000000
--- a/apps/backend/pkg/claudecode/types.go
+++ /dev/null
@@ -1,450 +0,0 @@
-// Package claudecode provides types and client for the Claude Code CLI stream-json protocol.
-// Claude Code uses a streaming JSON format over stdin/stdout with control requests for permissions.
-package claudecode
-
-import "encoding/json"
-
-// Message types from Claude Code CLI
-const (
- // MessageTypeSystem is the initial system message with session info
- MessageTypeSystem = "system"
- // MessageTypeAssistant contains text or thinking from the assistant
- MessageTypeAssistant = "assistant"
- // MessageTypeResult is the final result message
- MessageTypeResult = "result"
- // MessageTypeControlRequest is a control request (permission, hook)
- MessageTypeControlRequest = "control_request"
- // MessageTypeControlResponse is a response to a control request
- MessageTypeControlResponse = "control_response"
- // MessageTypeControlCancelRequest cancels a pending control request (e.g., permission dialog)
- MessageTypeControlCancelRequest = "control_cancel_request"
- // MessageTypeUser is a user message (prompt)
- MessageTypeUser = "user"
- // MessageTypeRateLimit is emitted when the Anthropic API rate-limits the agent.
- // Claude Code uses "rate_limit_event" as the message type.
- MessageTypeRateLimit = "rate_limit_event"
-)
-
-// Control request subtypes
-const (
- // SubtypeCanUseTool is a permission request for tool use
- SubtypeCanUseTool = "can_use_tool"
- // SubtypeHookCallback is a hook callback request
- SubtypeHookCallback = "hook_callback"
- // SubtypeInitialize initializes the session
- SubtypeInitialize = "initialize"
- // SubtypeInterrupt interrupts the current operation
- SubtypeInterrupt = "interrupt"
- // SubtypeSetPermissionMode sets the permission mode
- SubtypeSetPermissionMode = "set_permission_mode"
-)
-
-// Permission behaviors
-const (
- // BehaviorAllow allows the tool use
- BehaviorAllow = "allow"
- // BehaviorDeny denies the tool use
- BehaviorDeny = "deny"
-)
-
-// CLIMessage represents messages from Claude Code CLI stdout.
-// The message type determines which fields are populated.
-type CLIMessage struct {
- // Type is the message type (system, assistant, result, control_request, control_response, etc.)
- Type string `json:"type"`
-
- // UUID is a unique identifier for this message, used for --resume-session-at
- UUID string `json:"uuid,omitempty"`
-
- // For control_request messages (from Claude to us)
- RequestID string `json:"request_id,omitempty"`
- Request *ControlRequest `json:"request,omitempty"`
-
- // For control_response messages (from Claude back to us after we send a control_request)
- Response *IncomingControlResponse `json:"response,omitempty"`
-
- // For system messages
- SessionID string `json:"session_id,omitempty"`
- SessionStatus string `json:"session_status,omitempty"`
- SlashCommands []string `json:"slash_commands,omitempty"` // System message uses string array
- PermissionMode string `json:"permissionMode,omitempty"` // From system status messages (e.g. "plan", "bypassPermissions")
-
- // For subagent context (when running inside a Task tool call)
- ParentToolUseID string `json:"parent_tool_use_id,omitempty"`
-
- // For assistant messages
- Message *AssistantMessage `json:"message,omitempty"`
-
- // For result messages
- // Result can be either a string (error message) or an object (ResultData)
- Result json.RawMessage `json:"result,omitempty"`
- Subtype string `json:"subtype,omitempty"`
- CostUSD float64 `json:"total_cost_usd,omitempty"`
- DurationMS int64 `json:"duration_ms,omitempty"`
- DurationAPIMS int64 `json:"duration_api_ms,omitempty"`
- IsError bool `json:"is_error,omitempty"`
- Errors []string `json:"errors,omitempty"`
- NumTurns int `json:"num_turns,omitempty"`
- TotalInputTokens int64 `json:"total_input_tokens,omitempty"`
- TotalOutputTokens int64 `json:"total_output_tokens,omitempty"`
- ModelUsage map[string]ModelUsageStats `json:"model_usage,omitempty"`
-
- // For rate_limit messages
- RateLimitInfo json.RawMessage `json:"rate_limit_info,omitempty"`
-
- // For user messages: replay/synthetic flags.
- // IsReplay is true when the message is historical context echoed on resume.
- // IsSynthetic is true for Claude-generated internal messages (checkpoint, injected context).
- IsReplay bool `json:"isReplay,omitempty"`
- IsSynthetic bool `json:"isSynthetic,omitempty"`
-
- // For user messages: rich metadata about tool execution results.
- // Contains structured data like {stdout, stderr} for Bash, {oldTodos, newTodos} for TodoWrite,
- // or {status, agentId, totalDurationMs, totalTokens, totalToolUseCount} for Task (sub-agent).
- ToolUseResult json.RawMessage `json:"tool_use_result,omitempty"`
-
- // Raw message for parsing content blocks
- RawContent json.RawMessage `json:"-"`
-}
-
-// AssistantMessage contains the assistant's response content.
-// Note: For user messages (type="user"), Content may be a plain string instead of []ContentBlock.
-// Use RawContent and GetContentBlocks()/GetContentString() for flexible parsing.
-type AssistantMessage struct {
- Role string `json:"role"`
- Content json.RawMessage `json:"content,omitempty"` // Can be string or []ContentBlock
- Model string `json:"model,omitempty"`
- StopReason string `json:"stop_reason,omitempty"`
- Usage *Usage `json:"usage,omitempty"`
-}
-
-// GetContentBlocks attempts to parse Content as []ContentBlock.
-// Returns nil if Content is a string or cannot be parsed.
-func (m *AssistantMessage) GetContentBlocks() []ContentBlock {
- if len(m.Content) == 0 {
- return nil
- }
- var blocks []ContentBlock
- if err := json.Unmarshal(m.Content, &blocks); err != nil {
- return nil
- }
- return blocks
-}
-
-// GetContentString attempts to parse Content as a plain string.
-// Returns empty string if Content is []ContentBlock or cannot be parsed.
-func (m *AssistantMessage) GetContentString() string {
- if len(m.Content) == 0 {
- return ""
- }
- var s string
- if err := json.Unmarshal(m.Content, &s); err != nil {
- return ""
- }
- return s
-}
-
-// ContentBlock represents a block of content in an assistant message.
-type ContentBlock struct {
- Type string `json:"type"`
-
- // For text blocks
- Text string `json:"text,omitempty"`
-
- // For thinking blocks
- Thinking string `json:"thinking,omitempty"`
-
- // For tool_use blocks
- ID string `json:"id,omitempty"`
- Name string `json:"name,omitempty"`
- Input map[string]any `json:"input,omitempty"`
-
- // For tool_result blocks.
- // Content can be a string or an array of text blocks (sub-agent results use arrays).
- // Use GetContentString() to get the text regardless of format.
- ToolUseID string `json:"tool_use_id,omitempty"`
- RawContent json.RawMessage `json:"content,omitempty"`
- IsError bool `json:"is_error,omitempty"`
-}
-
-// GetContentString returns tool_result content as a string.
-// If content is a plain string, returns it directly.
-// If content is an array of text blocks [{type, text}], concatenates all text values.
-func (b *ContentBlock) GetContentString() string {
- if len(b.RawContent) == 0 {
- return ""
- }
-
- // Try as plain string first
- var s string
- if err := json.Unmarshal(b.RawContent, &s); err == nil {
- return s
- }
-
- // Try as array of text blocks
- var blocks []struct {
- Text string `json:"text"`
- }
- if err := json.Unmarshal(b.RawContent, &blocks); err == nil {
- var result string
- for i, block := range blocks {
- if i > 0 {
- result += "\n"
- }
- result += block.Text
- }
- return result
- }
-
- return ""
-}
-
-// Usage contains token usage information.
-type Usage struct {
- InputTokens int64 `json:"input_tokens"`
- OutputTokens int64 `json:"output_tokens"`
- CacheCreationInputTokens int64 `json:"cache_creation_input_tokens,omitempty"`
- CacheReadInputTokens int64 `json:"cache_read_input_tokens,omitempty"`
-}
-
-// ResultData contains the final result information.
-type ResultData struct {
- Text string `json:"text,omitempty"`
- SessionID string `json:"session_id,omitempty"`
-}
-
-// GetResultData attempts to parse the Result field as a ResultData object.
-// Returns nil if Result is empty, a string, or cannot be parsed as ResultData.
-func (m *CLIMessage) GetResultData() *ResultData {
- if len(m.Result) == 0 {
- return nil
- }
- var data ResultData
- if err := json.Unmarshal(m.Result, &data); err != nil {
- return nil
- }
- return &data
-}
-
-// GetResultString returns the Result field as a string.
-// This is used when the result is an error message string.
-func (m *CLIMessage) GetResultString() string {
- if len(m.Result) == 0 {
- return ""
- }
- var s string
- if err := json.Unmarshal(m.Result, &s); err != nil {
- // Not a string, return empty
- return ""
- }
- return s
-}
-
-// ModelUsageStats contains per-model usage statistics from result message.
-// The context_window field provides the actual model context window size.
-type ModelUsageStats struct {
- ContextWindow *int64 `json:"context_window,omitempty"`
-}
-
-// ControlRequest represents a control request from Claude Code CLI.
-// This is used for permission requests (can_use_tool) and hook callbacks.
-type ControlRequest struct {
- // Subtype identifies the type of control request
- Subtype string `json:"subtype"`
-
- // For can_use_tool requests
- ToolName string `json:"tool_name,omitempty"`
- Input map[string]any `json:"input,omitempty"`
- ToolUseID string `json:"tool_use_id,omitempty"`
- BlockedPaths string `json:"blocked_paths,omitempty"`
-
- // For hook_callback requests.
- // Note: hook data (tool_name, tool_input, hook_event_name) is in the Input field,
- // not a separate field — Claude Code sends it under "input" for both can_use_tool
- // and hook_callback subtypes.
- CallbackID string `json:"callback_id,omitempty"`
-
- // Permission suggestions from Claude
- PermissionSuggestions []PermissionUpdate `json:"permission_suggestions,omitempty"`
-}
-
-// PermissionUpdate represents a permission rule update.
-type PermissionUpdate struct {
- Tool string `json:"tool"`
- Pattern string `json:"pattern,omitempty"`
- Allow bool `json:"allow"`
-}
-
-// ControlResponseMessage is the message sent to respond to control requests.
-type ControlResponseMessage struct {
- Type string `json:"type"` // "control_response"
- RequestID string `json:"request_id"`
- Response *ControlResponse `json:"response"`
-}
-
-// IncomingControlResponse represents a control_response message from Claude Code CLI
-// (response to a control_request we sent, like initialize).
-type IncomingControlResponse struct {
- // Subtype is the response type (success, error)
- Subtype string `json:"subtype"`
-
- // RequestID is the ID of the control_request this responds to
- RequestID string `json:"request_id"`
-
- // Response contains the response data (e.g., slash_commands for initialize)
- Response *InitializeResponseData `json:"response,omitempty"`
-
- // Error message if subtype is "error"
- Error string `json:"error,omitempty"`
-}
-
-// InitializeResponseData contains the response data from an initialize control request.
-type InitializeResponseData struct {
- // Commands are the available commands (Claude Code uses "commands" not "slash_commands")
- Commands []Command `json:"commands,omitempty"`
-
- // Agents are the available agent names
- Agents []string `json:"agents,omitempty"`
-}
-
-// Command represents an available command from the initialize response.
-type Command struct {
- Name string `json:"name"`
- Description string `json:"description,omitempty"`
- ArgumentHint string `json:"argumentHint,omitempty"`
-}
-
-// ControlResponse is the response to a control request.
-type ControlResponse struct {
- // Subtype is the response type (success, error)
- Subtype string `json:"subtype"`
-
- // For success responses — holds a *PermissionResult for can_use_tool,
- // or a map[string]any for hook callbacks (hookSpecificOutput, decision/reason).
- Result any `json:"result,omitempty"`
-
- // For error responses
- Error string `json:"error,omitempty"`
-}
-
-// PermissionResult is the result for tool approval responses.
-type PermissionResult struct {
- // Behavior is "allow" or "deny"
- Behavior string `json:"behavior"`
-
- // UpdatedInput allows modifying the tool input
- UpdatedInput any `json:"updatedInput,omitempty"`
-
- // UpdatedPermissions adds permission rules for future requests
- UpdatedPermissions []PermissionUpdate `json:"updatedPermissions,omitempty"`
-
- // Message provides feedback to the model
- Message string `json:"message,omitempty"`
-
- // Interrupt stops the current operation (for deny)
- Interrupt *bool `json:"interrupt,omitempty"`
-}
-
-// SDKControlRequest is a control request sent to Claude Code CLI.
-// Used for initialize, interrupt, and other control operations.
-type SDKControlRequest struct {
- Type string `json:"type"` // "control_request"
- RequestID string `json:"request_id"`
- Request SDKControlRequestBody `json:"request"`
-}
-
-// SDKControlRequestBody contains the body of an SDK control request.
-type SDKControlRequestBody struct {
- // Subtype identifies the operation (initialize, interrupt, set_permission_mode)
- Subtype string `json:"subtype"`
-
- // For initialize requests
- Hooks map[string]any `json:"hooks,omitempty"`
-
- // For set_permission_mode requests
- Mode string `json:"mode,omitempty"`
-}
-
-// HookConfig defines hook configuration passed during initialize.
-type HookConfig struct {
- PreToolUse []HookEntry `json:"PreToolUse,omitempty"`
- Stop []HookEntry `json:"Stop,omitempty"`
-}
-
-// HookEntry defines a single hook entry with a matcher pattern and callback IDs.
-type HookEntry struct {
- Matcher string `json:"matcher,omitempty"`
- HookCallbackIDs []string `json:"hookCallbackIds"`
-}
-
-// ToMap converts HookConfig to map[string]any for use in SDKControlRequestBody.Hooks.
-func (h *HookConfig) ToMap() map[string]any {
- result := make(map[string]any)
- if len(h.PreToolUse) > 0 {
- result["PreToolUse"] = h.PreToolUse
- }
- if len(h.Stop) > 0 {
- result["Stop"] = h.Stop
- }
- return result
-}
-
-// UserMessage is sent to provide a prompt to Claude Code.
-type UserMessage struct {
- Type string `json:"type"` // "user"
- Message UserMessageBody `json:"message"`
-}
-
-// UserMessageBody contains the user message content.
-type UserMessageBody struct {
- Role string `json:"role"` // "user"
- Content string `json:"content"`
-}
-
-// StreamEvent represents a streaming event from Claude Code.
-// These are partial content updates during processing.
-type StreamEvent struct {
- Type string `json:"type"`
-
- // Content stream events
- Index int `json:"index,omitempty"`
- ContentType string `json:"content_type,omitempty"`
-
- // For text_delta events
- Delta *TextDelta `json:"delta,omitempty"`
-
- // For thinking_delta events
- ThinkingDelta string `json:"thinking_delta,omitempty"`
-}
-
-// TextDelta contains a partial text update.
-type TextDelta struct {
- Type string `json:"type"`
- Text string `json:"text,omitempty"`
-}
-
-// ToolApprovalOptions represents the available options for tool approval.
-type ToolApprovalOptions struct {
- Allow bool `json:"allow"`
- AlwaysAllow bool `json:"always_allow"`
- Deny bool `json:"deny"`
-}
-
-// Common tool names used by Claude Code
-const (
- ToolBash = "Bash"
- ToolWrite = "Write"
- ToolEdit = "Edit"
- ToolNotebookEdit = "NotebookEdit"
- ToolRead = "Read"
- ToolGlob = "Glob"
- ToolGrep = "Grep"
- ToolTask = "Task"
- ToolTaskCreate = "TaskCreate"
- ToolTaskUpdate = "TaskUpdate"
- ToolTaskList = "TaskList"
- ToolTaskGet = "TaskGet"
- ToolTodoWrite = "TodoWrite"
- ToolWebFetch = "WebFetch"
- ToolWebSearch = "WebSearch"
-)
diff --git a/apps/backend/pkg/claudecode/types_test.go b/apps/backend/pkg/claudecode/types_test.go
deleted file mode 100644
index f79e5796ee..0000000000
--- a/apps/backend/pkg/claudecode/types_test.go
+++ /dev/null
@@ -1,684 +0,0 @@
-package claudecode
-
-import (
- "encoding/json"
- "testing"
-)
-
-func TestCLIMessage_GetResultData(t *testing.T) {
- tests := []struct {
- name string
- result json.RawMessage
- wantNil bool
- wantText string
- }{
- {
- name: "empty result",
- result: nil,
- wantNil: true,
- },
- {
- name: "string result (error)",
- result: json.RawMessage(`"error message"`),
- wantNil: true, // GetResultData returns nil for strings
- },
- {
- name: "object result with text",
- result: json.RawMessage(`{"text":"success message","session_id":"abc123"}`),
- wantNil: false,
- wantText: "success message",
- },
- {
- name: "invalid JSON",
- result: json.RawMessage(`{invalid`),
- wantNil: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- msg := &CLIMessage{Result: tt.result}
- got := msg.GetResultData()
- switch {
- case tt.wantNil:
- if got != nil {
- t.Errorf("GetResultData() = %v, want nil", got)
- }
- case got == nil:
- t.Fatalf("GetResultData() = nil, want non-nil")
- case got.Text != tt.wantText:
- t.Errorf("GetResultData().Text = %q, want %q", got.Text, tt.wantText)
- }
- })
- }
-}
-
-func TestCLIMessage_GetResultString(t *testing.T) {
- tests := []struct {
- name string
- result json.RawMessage
- want string
- }{
- {
- name: "empty result",
- result: nil,
- want: "",
- },
- {
- name: "string result",
- result: json.RawMessage(`"error message"`),
- want: "error message",
- },
- {
- name: "object result",
- result: json.RawMessage(`{"text":"success"}`),
- want: "", // GetResultString returns empty for objects
- },
- {
- name: "invalid JSON",
- result: json.RawMessage(`{invalid`),
- want: "",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- msg := &CLIMessage{Result: tt.result}
- got := msg.GetResultString()
- if got != tt.want {
- t.Errorf("GetResultString() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-func TestCLIMessage_JSONParsing(t *testing.T) {
- // Test parsing a system message
- systemJSON := `{"type":"system","session_id":"abc123","session_status":"active"}`
- var systemMsg CLIMessage
- if err := json.Unmarshal([]byte(systemJSON), &systemMsg); err != nil {
- t.Fatalf("failed to parse system message: %v", err)
- }
- if systemMsg.Type != MessageTypeSystem {
- t.Errorf("Type = %q, want %q", systemMsg.Type, MessageTypeSystem)
- }
- if systemMsg.SessionID != "abc123" {
- t.Errorf("SessionID = %q, want %q", systemMsg.SessionID, "abc123")
- }
-
- // Test parsing an assistant message
- assistantJSON := `{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Hello"}],"model":"claude-3"}}`
- var assistantMsg CLIMessage
- if err := json.Unmarshal([]byte(assistantJSON), &assistantMsg); err != nil {
- t.Fatalf("failed to parse assistant message: %v", err)
- }
- if assistantMsg.Type != MessageTypeAssistant {
- t.Errorf("Type = %q, want %q", assistantMsg.Type, MessageTypeAssistant)
- }
- if assistantMsg.Message == nil {
- t.Fatal("Message is nil")
- }
- if assistantMsg.Message.Model != "claude-3" {
- t.Errorf("Message.Model = %q, want %q", assistantMsg.Message.Model, "claude-3")
- }
-}
-
-func TestControlRequest_JSONParsing(t *testing.T) {
- // Test can_use_tool request
- jsonStr := `{"subtype":"can_use_tool","tool_name":"Bash","input":{"command":"ls -la"},"tool_use_id":"tool123"}`
- var req ControlRequest
- if err := json.Unmarshal([]byte(jsonStr), &req); err != nil {
- t.Fatalf("failed to parse control request: %v", err)
- }
- if req.Subtype != SubtypeCanUseTool {
- t.Errorf("Subtype = %q, want %q", req.Subtype, SubtypeCanUseTool)
- }
- if req.ToolName != ToolBash {
- t.Errorf("ToolName = %q, want %q", req.ToolName, ToolBash)
- }
- if req.Input["command"] != "ls -la" {
- t.Errorf("Input[command] = %v, want %q", req.Input["command"], "ls -la")
- }
-}
-
-func TestControlResponseMessage_JSONMarshal(t *testing.T) {
- resp := &ControlResponseMessage{
- Type: MessageTypeControlResponse,
- RequestID: "req123",
- Response: &ControlResponse{
- Subtype: "success",
- Result: &PermissionResult{
- Behavior: BehaviorAllow,
- },
- },
- }
-
- data, err := json.Marshal(resp)
- if err != nil {
- t.Fatalf("failed to marshal: %v", err)
- }
-
- var parsed map[string]any
- if err := json.Unmarshal(data, &parsed); err != nil {
- t.Fatalf("failed to parse result: %v", err)
- }
-
- if parsed["type"] != MessageTypeControlResponse {
- t.Errorf("type = %v, want %q", parsed["type"], MessageTypeControlResponse)
- }
- if parsed["request_id"] != "req123" {
- t.Errorf("request_id = %v, want %q", parsed["request_id"], "req123")
- }
-}
-
-func TestUserMessage_JSONMarshal(t *testing.T) {
- msg := &UserMessage{
- Type: MessageTypeUser,
- Message: UserMessageBody{
- Role: "user",
- Content: "Hello, Claude!",
- },
- }
-
- data, err := json.Marshal(msg)
- if err != nil {
- t.Fatalf("failed to marshal: %v", err)
- }
-
- expected := `{"type":"user","message":{"role":"user","content":"Hello, Claude!"}}`
- if string(data) != expected {
- t.Errorf("Marshal() = %s, want %s", string(data), expected)
- }
-}
-
-func TestContentBlock_Types(t *testing.T) {
- tests := []struct {
- name string
- json string
- check func(t *testing.T, block ContentBlock)
- }{
- {
- name: "text block",
- json: `{"type":"text","text":"Hello world"}`,
- check: func(t *testing.T, block ContentBlock) {
- if block.Type != "text" {
- t.Errorf("Type = %q, want %q", block.Type, "text")
- }
- if block.Text != "Hello world" {
- t.Errorf("Text = %q, want %q", block.Text, "Hello world")
- }
- },
- },
- {
- name: "thinking block",
- json: `{"type":"thinking","thinking":"Let me analyze..."}`,
- check: func(t *testing.T, block ContentBlock) {
- if block.Type != "thinking" {
- t.Errorf("Type = %q, want %q", block.Type, "thinking")
- }
- if block.Thinking != "Let me analyze..." {
- t.Errorf("Thinking = %q, want %q", block.Thinking, "Let me analyze...")
- }
- },
- },
- {
- name: "tool_use block",
- json: `{"type":"tool_use","id":"tool123","name":"Bash","input":{"command":"ls"}}`,
- check: func(t *testing.T, block ContentBlock) {
- if block.Type != "tool_use" {
- t.Errorf("Type = %q, want %q", block.Type, "tool_use")
- }
- if block.ID != "tool123" {
- t.Errorf("ID = %q, want %q", block.ID, "tool123")
- }
- if block.Name != "Bash" {
- t.Errorf("Name = %q, want %q", block.Name, "Bash")
- }
- },
- },
- {
- name: "tool_result block",
- json: `{"type":"tool_result","tool_use_id":"tool123","content":"output","is_error":false}`,
- check: func(t *testing.T, block ContentBlock) {
- if block.Type != "tool_result" {
- t.Errorf("Type = %q, want %q", block.Type, "tool_result")
- }
- if block.ToolUseID != "tool123" {
- t.Errorf("ToolUseID = %q, want %q", block.ToolUseID, "tool123")
- }
- if block.GetContentString() != "output" {
- t.Errorf("Content = %q, want %q", block.GetContentString(), "output")
- }
- },
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var block ContentBlock
- if err := json.Unmarshal([]byte(tt.json), &block); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- tt.check(t, block)
- })
- }
-}
-
-func TestModelUsageStats_ContextWindow(t *testing.T) {
- jsonStr := `{"context_window": 200000}`
- var stats ModelUsageStats
- if err := json.Unmarshal([]byte(jsonStr), &stats); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if stats.ContextWindow == nil {
- t.Fatal("ContextWindow is nil")
- }
- if *stats.ContextWindow != 200000 {
- t.Errorf("ContextWindow = %d, want %d", *stats.ContextWindow, 200000)
- }
-
- // Test nil context window
- jsonStr2 := `{}`
- var stats2 ModelUsageStats
- if err := json.Unmarshal([]byte(jsonStr2), &stats2); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if stats2.ContextWindow != nil {
- t.Errorf("ContextWindow = %v, want nil", stats2.ContextWindow)
- }
-}
-
-func TestAssistantMessage_GetContentBlocks(t *testing.T) {
- tests := []struct {
- name string
- content string
- wantCount int
- wantType string
- }{
- {
- name: "array of content blocks",
- content: `[{"type":"text","text":"Hello"},{"type":"text","text":"World"}]`,
- wantCount: 2,
- wantType: "text",
- },
- {
- name: "single content block",
- content: `[{"type":"thinking","thinking":"Let me think..."}]`,
- wantCount: 1,
- wantType: "thinking",
- },
- {
- name: "empty array",
- content: `[]`,
- wantCount: 0,
- wantType: "",
- },
- {
- name: "string content (not blocks)",
- content: `"This is a string"`,
- wantCount: 0,
- wantType: "",
- },
- {
- name: "empty content",
- content: ``,
- wantCount: 0,
- wantType: "",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- msg := &AssistantMessage{
- Content: json.RawMessage(tt.content),
- }
- blocks := msg.GetContentBlocks()
- if len(blocks) != tt.wantCount {
- t.Errorf("GetContentBlocks() returned %d blocks, want %d", len(blocks), tt.wantCount)
- }
- if tt.wantCount > 0 && blocks[0].Type != tt.wantType {
- t.Errorf("GetContentBlocks()[0].Type = %q, want %q", blocks[0].Type, tt.wantType)
- }
- })
- }
-}
-
-func TestAssistantMessage_GetContentString(t *testing.T) {
- tests := []struct {
- name string
- content string
- want string
- }{
- {
- name: "plain string content",
- content: `"Hello, World!"`,
- want: "Hello, World!",
- },
- {
- name: "string with local-command-stdout tags",
- content: `"Command output here"`,
- want: "Command output here",
- },
- {
- name: "empty string",
- content: `""`,
- want: "",
- },
- {
- name: "array content (not string)",
- content: `[{"type":"text","text":"Hello"}]`,
- want: "",
- },
- {
- name: "empty content",
- content: ``,
- want: "",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- msg := &AssistantMessage{
- Content: json.RawMessage(tt.content),
- }
- got := msg.GetContentString()
- if got != tt.want {
- t.Errorf("GetContentString() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-func TestIncomingControlResponse_JSONParsing(t *testing.T) {
- // Test successful initialize response
- jsonStr := `{
- "subtype": "success",
- "request_id": "req-123",
- "response": {
- "commands": [
- {"name": "cost", "description": "Show cost"},
- {"name": "context", "description": "Show context"}
- ],
- "agents": ["Bash", "Explore"]
- }
- }`
- var resp IncomingControlResponse
- if err := json.Unmarshal([]byte(jsonStr), &resp); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if resp.Subtype != "success" {
- t.Errorf("Subtype = %q, want %q", resp.Subtype, "success")
- }
- if resp.RequestID != "req-123" {
- t.Errorf("RequestID = %q, want %q", resp.RequestID, "req-123")
- }
- if resp.Response == nil {
- t.Fatal("Response is nil")
- }
- if len(resp.Response.Commands) != 2 {
- t.Errorf("Commands count = %d, want %d", len(resp.Response.Commands), 2)
- }
- if resp.Response.Commands[0].Name != "cost" {
- t.Errorf("Commands[0].Name = %q, want %q", resp.Response.Commands[0].Name, "cost")
- }
- if len(resp.Response.Agents) != 2 {
- t.Errorf("Agents count = %d, want %d", len(resp.Response.Agents), 2)
- }
-
- // Test error response
- errorJSON := `{"subtype": "error", "request_id": "req-456", "error": "Something went wrong"}`
- var errorResp IncomingControlResponse
- if err := json.Unmarshal([]byte(errorJSON), &errorResp); err != nil {
- t.Fatalf("failed to parse error response: %v", err)
- }
- if errorResp.Subtype != "error" {
- t.Errorf("Subtype = %q, want %q", errorResp.Subtype, "error")
- }
- if errorResp.Error != "Something went wrong" {
- t.Errorf("Error = %q, want %q", errorResp.Error, "Something went wrong")
- }
-}
-
-func TestCLIMessage_IsReplay_IsSynthetic(t *testing.T) {
- tests := []struct {
- name string
- json string
- wantReplay bool
- wantSynthetic bool
- }{
- {
- name: "replay user message",
- json: `{"type":"user","uuid":"abc","session_id":"sess-1","isReplay":true,"message":{"role":"user","content":"hello"}}`,
- wantReplay: true,
- wantSynthetic: false,
- },
- {
- name: "synthetic user message",
- json: `{"type":"user","uuid":"abc","session_id":"sess-1","isSynthetic":true,"message":{"role":"user","content":"checkpoint"}}`,
- wantReplay: false,
- wantSynthetic: true,
- },
- {
- name: "replay and synthetic",
- json: `{"type":"user","uuid":"abc","isReplay":true,"isSynthetic":true,"message":{"role":"user","content":"old"}}`,
- wantReplay: true,
- wantSynthetic: true,
- },
- {
- name: "neither replay nor synthetic",
- json: `{"type":"user","uuid":"abc","message":{"role":"user","content":"hello"}}`,
- wantReplay: false,
- wantSynthetic: false,
- },
- {
- name: "assistant message has no replay fields",
- json: `{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"hi"}]}}`,
- wantReplay: false,
- wantSynthetic: false,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var msg CLIMessage
- if err := json.Unmarshal([]byte(tt.json), &msg); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if msg.IsReplay != tt.wantReplay {
- t.Errorf("IsReplay = %v, want %v", msg.IsReplay, tt.wantReplay)
- }
- if msg.IsSynthetic != tt.wantSynthetic {
- t.Errorf("IsSynthetic = %v, want %v", msg.IsSynthetic, tt.wantSynthetic)
- }
- })
- }
-}
-
-func TestHookConfig_ToMap(t *testing.T) {
- tests := []struct {
- name string
- config HookConfig
- wantKeys []string
- absentKeys []string
- }{
- {
- name: "empty config",
- config: HookConfig{},
- wantKeys: nil,
- absentKeys: []string{"PreToolUse", "Stop"},
- },
- {
- name: "PreToolUse only",
- config: HookConfig{
- PreToolUse: []HookEntry{
- {Matcher: `^Bash$`, HookCallbackIDs: []string{"tool_approval"}},
- },
- },
- wantKeys: []string{"PreToolUse"},
- absentKeys: []string{"Stop"},
- },
- {
- name: "Stop only",
- config: HookConfig{
- Stop: []HookEntry{
- {HookCallbackIDs: []string{"stop_git_check"}},
- },
- },
- wantKeys: []string{"Stop"},
- absentKeys: []string{"PreToolUse"},
- },
- {
- name: "both hooks",
- config: HookConfig{
- PreToolUse: []HookEntry{
- {Matcher: `^Bash$`, HookCallbackIDs: []string{"tool_approval"}},
- },
- Stop: []HookEntry{
- {HookCallbackIDs: []string{"stop_git_check"}},
- },
- },
- wantKeys: []string{"PreToolUse", "Stop"},
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- result := tt.config.ToMap()
- for _, key := range tt.wantKeys {
- if _, ok := result[key]; !ok {
- t.Errorf("ToMap() missing key %q", key)
- }
- }
- for _, key := range tt.absentKeys {
- if _, ok := result[key]; ok {
- t.Errorf("ToMap() should not have key %q", key)
- }
- }
- })
- }
-}
-
-func TestHookConfig_ToMap_PreservesEntries(t *testing.T) {
- cfg := HookConfig{
- PreToolUse: []HookEntry{
- {Matcher: `^Bash$`, HookCallbackIDs: []string{"tool_approval"}},
- {Matcher: `^Edit$`, HookCallbackIDs: []string{"auto_approve"}},
- },
- }
- result := cfg.ToMap()
- entries, ok := result["PreToolUse"].([]HookEntry)
- if !ok {
- t.Fatal("PreToolUse is not []HookEntry")
- }
- if len(entries) != 2 {
- t.Errorf("PreToolUse has %d entries, want 2", len(entries))
- }
- if entries[0].Matcher != `^Bash$` {
- t.Errorf("entries[0].Matcher = %q, want %q", entries[0].Matcher, `^Bash$`)
- }
- if entries[1].HookCallbackIDs[0] != "auto_approve" {
- t.Errorf("entries[1].HookCallbackIDs[0] = %q, want %q", entries[1].HookCallbackIDs[0], "auto_approve")
- }
-}
-
-func TestContentBlock_GetContentString(t *testing.T) {
- tests := []struct {
- name string
- json string
- want string
- }{
- {
- name: "string content",
- json: `{"type":"tool_result","tool_use_id":"t1","content":"hello world"}`,
- want: "hello world",
- },
- {
- name: "array of text blocks",
- json: `{"type":"tool_result","tool_use_id":"t1","content":[{"type":"text","text":"line 1"},{"type":"text","text":"line 2"}]}`,
- want: "line 1\nline 2",
- },
- {
- name: "single text block array",
- json: `{"type":"tool_result","tool_use_id":"t1","content":[{"type":"text","text":"only line"}]}`,
- want: "only line",
- },
- {
- name: "empty content",
- json: `{"type":"tool_result","tool_use_id":"t1"}`,
- want: "",
- },
- {
- name: "empty string content",
- json: `{"type":"tool_result","tool_use_id":"t1","content":""}`,
- want: "",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var block ContentBlock
- if err := json.Unmarshal([]byte(tt.json), &block); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- got := block.GetContentString()
- if got != tt.want {
- t.Errorf("GetContentString() = %q, want %q", got, tt.want)
- }
- })
- }
-}
-
-func TestCLIMessage_RateLimitEventType(t *testing.T) {
- // Claude Code sends "rate_limit_event", not "rate_limit"
- jsonStr := `{"type":"rate_limit_event","rate_limit_info":{"status":"allowed"},"session_id":"sess-1"}`
- var msg CLIMessage
- if err := json.Unmarshal([]byte(jsonStr), &msg); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if msg.Type != MessageTypeRateLimit {
- t.Errorf("Type = %q, want %q (MessageTypeRateLimit)", msg.Type, MessageTypeRateLimit)
- }
-}
-
-func TestCLIMessage_TotalCostUSD(t *testing.T) {
- // Claude Code sends "total_cost_usd", not "cost_usd"
- jsonStr := `{"type":"result","total_cost_usd":0.123,"session_id":"sess-1"}`
- var msg CLIMessage
- if err := json.Unmarshal([]byte(jsonStr), &msg); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if msg.CostUSD != 0.123 {
- t.Errorf("CostUSD = %f, want %f", msg.CostUSD, 0.123)
- }
-}
-
-func TestCLIMessage_ToolUseResult(t *testing.T) {
- // Sub-agent task result with rich metadata
- jsonStr := `{
- "type":"user",
- "message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"result"}]},
- "tool_use_result":{"status":"completed","agentId":"abc","totalDurationMs":1500,"totalTokens":4000,"totalToolUseCount":2},
- "session_id":"sess-1"
- }`
- var msg CLIMessage
- if err := json.Unmarshal([]byte(jsonStr), &msg); err != nil {
- t.Fatalf("failed to parse: %v", err)
- }
- if len(msg.ToolUseResult) == 0 {
- t.Fatal("ToolUseResult is empty")
- }
-
- var result map[string]any
- if err := json.Unmarshal(msg.ToolUseResult, &result); err != nil {
- t.Fatalf("failed to parse ToolUseResult: %v", err)
- }
- if result["status"] != "completed" {
- t.Errorf("status = %v, want %q", result["status"], "completed")
- }
- if result["agentId"] != "abc" {
- t.Errorf("agentId = %v, want %q", result["agentId"], "abc")
- }
- if result["totalDurationMs"].(float64) != 1500 {
- t.Errorf("totalDurationMs = %v, want %v", result["totalDurationMs"], 1500)
- }
-}
diff --git a/apps/backend/pkg/codex/client.go b/apps/backend/pkg/codex/client.go
deleted file mode 100644
index 2079d1257f..0000000000
--- a/apps/backend/pkg/codex/client.go
+++ /dev/null
@@ -1,250 +0,0 @@
-package codex
-
-import (
- "bufio"
- "context"
- "encoding/json"
- "fmt"
- "io"
- "sync"
- "sync/atomic"
-
- "github.com/kandev/kandev/internal/common/logger"
- "go.uber.org/zap"
-)
-
-// Client handles Codex JSON-RPC communication over stdin/stdout streams.
-// Unlike standard JSON-RPC 2.0, Codex omits the "jsonrpc":"2.0" field.
-type Client struct {
- stdin io.Writer
- stdout io.Reader
-
- requestID atomic.Int64
- pending map[interface{}]chan *Response
- mu sync.Mutex
-
- onNotification func(method string, params json.RawMessage)
- onRequest func(id interface{}, method string, params json.RawMessage)
-
- logger *logger.Logger
- done chan struct{}
-}
-
-// NewClient creates a new Codex JSON-RPC client
-func NewClient(stdin io.Writer, stdout io.Reader, log *logger.Logger) *Client {
- return &Client{
- stdin: stdin,
- stdout: stdout,
- pending: make(map[interface{}]chan *Response),
- logger: log.WithFields(zap.String("component", "codex-client")),
- done: make(chan struct{}),
- }
-}
-
-// SetNotificationHandler sets the handler for incoming notifications
-func (c *Client) SetNotificationHandler(handler func(method string, params json.RawMessage)) {
- c.onNotification = handler
-}
-
-// SetRequestHandler sets the handler for incoming requests from the agent
-func (c *Client) SetRequestHandler(handler func(id interface{}, method string, params json.RawMessage)) {
- c.onRequest = handler
-}
-
-// SendResponse sends a response to an agent request
-func (c *Client) SendResponse(id interface{}, result interface{}, err *Error) error {
- var resultJSON json.RawMessage
- if result != nil && err == nil {
- var marshalErr error
- resultJSON, marshalErr = json.Marshal(result)
- if marshalErr != nil {
- return fmt.Errorf("failed to marshal result: %w", marshalErr)
- }
- }
- resp := &Response{ID: id, Result: resultJSON, Error: err}
- c.logger.Info("sending response to codex",
- zap.Any("id", id),
- zap.String("result", string(resultJSON)),
- zap.Any("error", err))
- return c.send(resp)
-}
-
-// Start begins reading responses from stdout
-func (c *Client) Start(ctx context.Context) {
- go c.readLoop(ctx)
-}
-
-// Stop stops the client
-func (c *Client) Stop() {
- close(c.done)
-}
-
-// Call sends a request and waits for a response
-func (c *Client) Call(ctx context.Context, method string, params interface{}) (*Response, error) {
- id := c.requestID.Add(1)
-
- var paramsJSON json.RawMessage
- if params != nil {
- var err error
- paramsJSON, err = json.Marshal(params)
- if err != nil {
- return nil, fmt.Errorf("failed to marshal params: %w", err)
- }
- }
-
- req := &Request{ID: id, Method: method, Params: paramsJSON}
-
- respCh := make(chan *Response, 1)
- c.mu.Lock()
- c.pending[id] = respCh
- c.mu.Unlock()
-
- defer func() {
- c.mu.Lock()
- delete(c.pending, id)
- c.mu.Unlock()
- }()
-
- if err := c.send(req); err != nil {
- return nil, err
- }
-
- select {
- case resp := <-respCh:
- return resp, nil
- case <-ctx.Done():
- return nil, ctx.Err()
- case <-c.done:
- return nil, fmt.Errorf("client closed")
- }
-}
-
-// Notify sends a notification (no response expected)
-func (c *Client) Notify(method string, params interface{}) error {
- var paramsJSON json.RawMessage
- if params != nil {
- var err error
- paramsJSON, err = json.Marshal(params)
- if err != nil {
- return fmt.Errorf("failed to marshal params: %w", err)
- }
- }
- notif := &Notification{Method: method, Params: paramsJSON}
- return c.send(notif)
-}
-
-func (c *Client) send(msg interface{}) error {
- data, err := json.Marshal(msg)
- if err != nil {
- return fmt.Errorf("failed to marshal message: %w", err)
- }
- data = append(data, '\n')
- _, err = c.stdin.Write(data)
- if err != nil {
- return fmt.Errorf("failed to write message: %w", err)
- }
- c.logger.Debug("codex: sent message", zap.String("data", string(data)))
- return nil
-}
-
-func (c *Client) readLoop(ctx context.Context) {
- scanner := bufio.NewScanner(c.stdout)
- buf := make([]byte, 0, 64*1024)
- scanner.Buffer(buf, 1024*1024)
-
- for scanner.Scan() {
- select {
- case <-ctx.Done():
- return
- case <-c.done:
- return
- default:
- }
-
- line := scanner.Bytes()
- if len(line) == 0 {
- continue
- }
- c.processCodexMessage(line)
- }
-
- if err := scanner.Err(); err != nil {
- c.logger.Error("read loop error", zap.Error(err))
- }
-}
-
-// processCodexMessage parses a single JSON line and routes it as a response, request, or notification.
-func (c *Client) processCodexMessage(line []byte) {
- var msg struct {
- ID interface{} `json:"id"`
- Method string `json:"method"`
- Result json.RawMessage `json:"result"`
- Error *Error `json:"error"`
- Params json.RawMessage `json:"params"`
- }
- if err := json.Unmarshal(line, &msg); err != nil {
- c.logger.Warn("failed to parse message", zap.Error(err))
- return
- }
-
- hasID := msg.ID != nil
- hasMethod := msg.Method != ""
- hasResult := msg.Result != nil
- hasError := msg.Error != nil
-
- c.logger.Info("codex: received message",
- zap.Bool("hasID", hasID),
- zap.Bool("hasMethod", hasMethod),
- zap.String("method", msg.Method))
-
- switch {
- case hasID && !hasMethod && (hasResult || hasError):
- c.handleResponse(&Response{ID: msg.ID, Result: msg.Result, Error: msg.Error})
- case hasID && hasMethod:
- c.logger.Info("codex: routing as request", zap.Any("id", msg.ID), zap.String("method", msg.Method))
- c.handleRequest(msg.ID, msg.Method, msg.Params)
- case hasMethod && !hasID:
- c.handleNotification(msg.Method, msg.Params)
- }
-}
-
-func (c *Client) handleResponse(resp *Response) {
- id := normalizeID(resp.ID)
- c.mu.Lock()
- ch, ok := c.pending[id]
- c.mu.Unlock()
- if ok {
- ch <- resp
- } else {
- c.logger.Warn("received response for unknown request", zap.Any("id", resp.ID))
- }
-}
-
-func normalizeID(id interface{}) interface{} {
- switch v := id.(type) {
- case float64:
- return int64(v)
- case json.Number:
- if i, err := v.Int64(); err == nil {
- return i
- }
- }
- return id
-}
-
-func (c *Client) handleNotification(method string, params json.RawMessage) {
- if c.onNotification != nil {
- c.onNotification(method, params)
- }
-}
-
-func (c *Client) handleRequest(id interface{}, method string, params json.RawMessage) {
- if c.onRequest != nil {
- c.onRequest(id, method, params)
- } else {
- c.logger.Warn("received request but no handler registered", zap.String("method", method))
- if err := c.SendResponse(id, nil, &Error{Code: MethodNotFound, Message: "Method not found"}); err != nil {
- c.logger.Warn("failed to send method not found response", zap.Error(err))
- }
- }
-}
diff --git a/apps/backend/pkg/codex/types.go b/apps/backend/pkg/codex/types.go
deleted file mode 100644
index b065132cd6..0000000000
--- a/apps/backend/pkg/codex/types.go
+++ /dev/null
@@ -1,422 +0,0 @@
-// Package codex provides types and client for the OpenAI Codex app-server protocol.
-// Codex uses a JSON-RPC 2.0 variant over stdio, but omits the "jsonrpc":"2.0" header.
-package codex
-
-import "encoding/json"
-
-// Request represents a Codex JSON-RPC request (without jsonrpc field)
-type Request struct {
- ID interface{} `json:"id,omitempty"`
- Method string `json:"method"`
- Params json.RawMessage `json:"params,omitempty"`
-}
-
-// Response represents a Codex JSON-RPC response
-type Response struct {
- ID interface{} `json:"id"`
- Result json.RawMessage `json:"result,omitempty"`
- Error *Error `json:"error,omitempty"`
-}
-
-// Notification represents a Codex notification (no id field)
-type Notification struct {
- Method string `json:"method"`
- Params json.RawMessage `json:"params,omitempty"`
-}
-
-// Error represents a JSON-RPC error
-type Error struct {
- Code int `json:"code"`
- Message string `json:"message"`
- Data any `json:"data,omitempty"`
-}
-
-// Standard error codes
-const (
- ParseError = -32700
- InvalidRequest = -32600
- MethodNotFound = -32601
- InvalidParams = -32602
- InternalError = -32603
-)
-
-// Codex method names
-const (
- MethodInitialize = "initialize"
- MethodInitialized = "initialized" // Notification
- MethodThreadStart = "thread/start"
- MethodThreadResume = "thread/resume"
- MethodThreadFork = "thread/fork"
- MethodThreadList = "thread/list"
- MethodThreadArchive = "thread/archive"
- MethodTurnStart = "turn/start"
- MethodTurnInterrupt = "turn/interrupt"
- MethodCommandExec = "command/exec"
- MethodModelList = "model/list"
- MethodSkillsList = "skills/list"
- MethodAccountRead = "account/read"
- MethodAccountLogout = "account/logout"
- MethodReviewStart = "review/start"
- MethodConfigRead = "config/read"
-)
-
-// Codex notification methods (server → client)
-const (
- NotifyThreadStarted = "thread/started"
- NotifyTurnStarted = "turn/started"
- NotifyTurnCompleted = "turn/completed"
- NotifyTurnDiffUpdated = "turn/diff/updated"
- NotifyTurnPlanUpdated = "turn/plan/updated"
- NotifyItemStarted = "item/started"
- NotifyItemCompleted = "item/completed"
- NotifyItemAgentMessageDelta = "item/agentMessage/delta"
- NotifyItemReasoningSummaryDelta = "item/reasoning/summaryTextDelta"
- NotifyItemReasoningTextDelta = "item/reasoning/textDelta"
- NotifyItemCmdExecOutputDelta = "item/commandExecution/outputDelta"
- NotifyItemCmdExecRequestApproval = "item/commandExecution/requestApproval"
- NotifyItemFileChangeRequestApproval = "item/fileChange/requestApproval"
- NotifyAccountUpdated = "account/updated"
- NotifyAccountLoginCompleted = "account/login/completed"
- NotifyError = "error"
- NotifyTokenCount = "token_count"
- NotifyThreadTokenUsageUpdated = "thread/tokenUsage/updated"
- NotifyContextCompacted = "context_compacted"
-)
-
-// InitializeParams for initialize request
-type InitializeParams struct {
- ClientInfo *ClientInfo `json:"clientInfo"`
-}
-
-// ClientInfo identifies the client
-type ClientInfo struct {
- Name string `json:"name"`
- Title string `json:"title,omitempty"`
- Version string `json:"version"`
-}
-
-// InitializeResult from initialize
-type InitializeResult struct {
- UserAgent string `json:"userAgent,omitempty"`
-}
-
-// ThreadStartParams for thread/start
-type ThreadStartParams struct {
- Model string `json:"model,omitempty"`
- Cwd string `json:"cwd,omitempty"`
- ApprovalPolicy string `json:"approvalPolicy,omitempty"` // "untrusted", "on-failure", "on-request", "never"
- Sandbox string `json:"sandbox,omitempty"` // "workspaceWrite", "readOnly", etc.
- SandboxPolicy *SandboxPolicy `json:"sandboxPolicy,omitempty"`
-}
-
-// SandboxPolicy configures sandbox behavior.
-// Type must use kebab-case values per Codex documentation:
-// - "read-only": prevents edits, command execution, and network access
-// - "workspace-write": allows reads, edits, and commands within the active workspace
-// - "danger-full-access": removes all sandbox constraints (not recommended)
-type SandboxPolicy struct {
- Type string `json:"type"` // "workspace-write", "read-only", "danger-full-access"
- WritableRoots []string `json:"writableRoots,omitempty"`
- NetworkAccess bool `json:"networkAccess,omitempty"`
-}
-
-// Thread represents a Codex thread (conversation)
-type Thread struct {
- ID string `json:"id"`
- Preview string `json:"preview,omitempty"`
- ModelProvider string `json:"modelProvider,omitempty"`
- CreatedAt int64 `json:"createdAt,omitempty"`
-}
-
-// ThreadStartResult from thread/start
-type ThreadStartResult struct {
- Thread *Thread `json:"thread"`
-}
-
-// ThreadResumeParams for thread/resume
-type ThreadResumeParams struct {
- ThreadID string `json:"threadId"`
- Cwd string `json:"cwd,omitempty"`
- ApprovalPolicy string `json:"approvalPolicy,omitempty"` // "untrusted", "on-failure", "on-request", "never"
- SandboxPolicy *SandboxPolicy `json:"sandboxPolicy,omitempty"`
-}
-
-// ThreadResumeResult from thread/resume
-type ThreadResumeResult struct {
- Thread *Thread `json:"thread"`
-}
-
-// UserInput represents input to a turn
-type UserInput struct {
- Type string `json:"type"` // "text", "image", "localImage", "skill"
- Text string `json:"text,omitempty"`
- URL string `json:"url,omitempty"`
- Path string `json:"path,omitempty"`
- Name string `json:"name,omitempty"`
-}
-
-// TurnStartParams for turn/start
-type TurnStartParams struct {
- ThreadID string `json:"threadId"`
- Input []UserInput `json:"input"`
-}
-
-// Turn represents a Codex turn within a thread
-type Turn struct {
- ID string `json:"id"`
- Status string `json:"status"` // "inProgress", "completed", "failed"
- Items []Item `json:"items"`
- Error *Error `json:"error,omitempty"`
-}
-
-// TurnStartResult from turn/start
-type TurnStartResult struct {
- Turn *Turn `json:"turn"`
-}
-
-// Item represents a Codex item (message, command, file change, etc.)
-type Item struct {
- ID string `json:"id"`
- Type string `json:"type"` // "userMessage", "agentMessage", "commandExecution", "fileChange", "reasoning", "mcpToolCall"
- Status string `json:"status"` // "inProgress", "completed", "failed"
-
- // For commandExecution type
- Command string `json:"command,omitempty"`
- Cwd string `json:"cwd,omitempty"`
- AggregatedOutput string `json:"aggregatedOutput,omitempty"`
- ExitCode *int `json:"exitCode,omitempty"`
- DurationMs *int `json:"durationMs,omitempty"`
-
- // For fileChange type
- Changes []FileChange `json:"changes,omitempty"`
-
- // For reasoning type - content can be objects like [{type: "text", text: "..."}]
- // or plain strings. FlexibleContent handles both formats.
- Summary FlexibleContent `json:"summary,omitempty"`
- Content FlexibleContent `json:"content,omitempty"`
-
- // For mcpToolCall type
- Server string `json:"server,omitempty"`
- Tool string `json:"tool,omitempty"`
- Arguments json.RawMessage `json:"arguments,omitempty"`
- Result json.RawMessage `json:"result,omitempty"`
- ToolError string `json:"error,omitempty"` // Named ToolError to avoid conflict with Error type
-}
-
-// ContentPart represents a content part in a Codex item.
-// This handles the OpenAI responses format where content is an array of typed objects.
-type ContentPart struct {
- Type string `json:"type,omitempty"` // "text", "output_text", "refusal", "input_text", etc.
- Text string `json:"text,omitempty"`
-}
-
-// FlexibleContent is a type that can unmarshal from either a string or []ContentPart.
-// Codex sometimes sends summary/content as a plain string, other times as an array.
-type FlexibleContent []ContentPart
-
-// UnmarshalJSON implements custom unmarshaling for FlexibleContent.
-// It handles both string and array formats from Codex.
-func (fc *FlexibleContent) UnmarshalJSON(data []byte) error {
- // Try to unmarshal as array first (most common case)
- var parts []ContentPart
- if err := json.Unmarshal(data, &parts); err == nil {
- *fc = parts
- return nil
- }
-
- // Try to unmarshal as string
- var str string
- if err := json.Unmarshal(data, &str); err == nil {
- *fc = []ContentPart{{Type: "text", Text: str}}
- return nil
- }
-
- // If both fail, return empty (don't fail parsing)
- *fc = nil
- return nil
-}
-
-// FileChange represents a file change in a fileChange item
-type FileChange struct {
- Path string `json:"path"`
- Kind FileChangeKind `json:"kind"`
- Diff string `json:"diff,omitempty"`
-}
-
-// FileChangeKind represents the type of file change
-type FileChangeKind struct {
- Type string `json:"type"` // "add", "modify", "delete"
-}
-
-// ItemStartedParams for item/started notification
-type ItemStartedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- Item *Item `json:"item"`
-}
-
-// ItemCompletedParams for item/completed notification
-type ItemCompletedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- Item *Item `json:"item"`
-}
-
-// AgentMessageDeltaParams for item/agentMessage/delta
-type AgentMessageDeltaParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- ItemID string `json:"itemId"`
- Delta string `json:"delta"`
-}
-
-// ReasoningDeltaParams for item/reasoning/textDelta and summaryTextDelta
-type ReasoningDeltaParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- ItemID string `json:"itemId"`
- Delta string `json:"delta"`
-}
-
-// CommandOutputDeltaParams for item/commandExecution/outputDelta
-type CommandOutputDeltaParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- ItemID string `json:"itemId"`
- Delta string `json:"delta"`
-}
-
-// CommandApprovalParams for item/commandExecution/requestApproval
-type CommandApprovalParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- ItemID string `json:"itemId"`
- Command string `json:"command"`
- Cwd string `json:"cwd,omitempty"`
- Reasoning string `json:"reasoning,omitempty"`
- Options []string `json:"options,omitempty"` // e.g., ["approve", "reject", "approveAlways"]
-}
-
-// FileChangeApprovalParams for item/fileChange/requestApproval
-type FileChangeApprovalParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- ItemID string `json:"itemId"`
- Path string `json:"path"`
- Diff string `json:"diff,omitempty"`
- Reasoning string `json:"reasoning,omitempty"`
- Options []string `json:"options,omitempty"`
-}
-
-// TurnCompletedParams for turn/completed notification
-type TurnCompletedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- Success bool `json:"success"`
- Error string `json:"error,omitempty"`
-}
-
-// TurnDiffUpdatedParams for turn/diff/updated notification
-type TurnDiffUpdatedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- Diff string `json:"diff"`
-}
-
-// TurnPlanUpdatedParams for turn/plan/updated notification
-type TurnPlanUpdatedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- Plan []PlanEntry `json:"plan"`
-}
-
-// PlanEntry represents a single plan item
-type PlanEntry struct {
- Description string `json:"description"`
- Status string `json:"status"` // "pending", "in_progress", "completed", "failed"
-}
-
-// CommandApprovalResponse for responding to command execution approval requests
-// Decision values: "accept", "acceptForSession", "decline", "cancel"
-type CommandApprovalResponse struct {
- Decision string `json:"decision"`
-}
-
-// FileChangeApprovalResponse for responding to file change approval requests
-// Decision values: "accept", "acceptForSession", "decline", "cancel"
-type FileChangeApprovalResponse struct {
- Decision string `json:"decision"`
-}
-
-// ErrorParams for error notification
-type ErrorParams struct {
- Code int `json:"code,omitempty"`
- Message string `json:"message"`
- Data any `json:"data,omitempty"`
-}
-
-// TokenCountParams for token_count notification
-// This is emitted by Codex after each turn to report token usage.
-type TokenCountParams struct {
- Info *TokenUsageInfo `json:"info,omitempty"`
- RateLimits *RateLimitSnapshot `json:"rateLimits,omitempty"`
-}
-
-// TokenUsageInfo contains detailed token usage information.
-type TokenUsageInfo struct {
- TotalTokenUsage *TokenUsage `json:"totalTokenUsage,omitempty"`
- LastTokenUsage *TokenUsage `json:"lastTokenUsage,omitempty"`
- ModelContextWindow *int64 `json:"modelContextWindow,omitempty"`
-}
-
-// TokenUsage contains token counts for a request/response cycle.
-type TokenUsage struct {
- InputTokens int32 `json:"inputTokens"`
- CachedInputTokens int32 `json:"cachedInputTokens"`
- OutputTokens int32 `json:"outputTokens"`
- ReasoningOutputTokens int32 `json:"reasoningOutputTokens"`
- TotalTokens int32 `json:"totalTokens"`
-}
-
-// ThreadTokenUsageUpdatedParams for thread/tokenUsage/updated notification.
-// This is emitted by Codex after each turn completes with token usage info.
-type ThreadTokenUsageUpdatedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
- TokenUsage *ThreadTokenUsage `json:"tokenUsage"`
-}
-
-// ThreadTokenUsage contains the token usage summary for a thread.
-type ThreadTokenUsage struct {
- Total *TokenUsage `json:"total,omitempty"`
- Last *TokenUsage `json:"last,omitempty"`
- ModelContextWindow int64 `json:"modelContextWindow"`
-}
-
-// RateLimitSnapshot contains rate limit information.
-type RateLimitSnapshot struct {
- Primary *RateLimitWindow `json:"primary,omitempty"`
- Secondary *RateLimitWindow `json:"secondary,omitempty"`
- Credits *CreditsSnapshot `json:"credits,omitempty"`
- PlanType *string `json:"planType,omitempty"`
-}
-
-// RateLimitWindow contains rate limit window information.
-type RateLimitWindow struct {
- UsedPercent int32 `json:"usedPercent"`
- WindowDurationMins *int64 `json:"windowDurationMins,omitempty"`
- ResetsAt *int64 `json:"resetsAt,omitempty"`
-}
-
-// CreditsSnapshot contains credits information (placeholder for future use).
-type CreditsSnapshot struct {
- Remaining *int64 `json:"remaining,omitempty"`
- Used *int64 `json:"used,omitempty"`
-}
-
-// ContextCompactedParams for context_compacted notification.
-// Emitted when the context has been compacted due to reaching limits.
-type ContextCompactedParams struct {
- ThreadID string `json:"threadId"`
- TurnID string `json:"turnId"`
-}
diff --git a/apps/backend/pkg/copilot/client.go b/apps/backend/pkg/copilot/client.go
deleted file mode 100644
index 5a4bc1c51f..0000000000
--- a/apps/backend/pkg/copilot/client.go
+++ /dev/null
@@ -1,389 +0,0 @@
-// Package copilot provides integration with the GitHub Copilot SDK.
-// This is a thin wrapper around github.com/github/copilot-sdk/go that
-// provides a consistent interface for the kandev agent system.
-//
-// When CLIUrl is configured, the SDK connects to an externally managed
-// Copilot CLI server via TCP (JSON-RPC). Otherwise, the SDK spawns and
-// manages the CLI process internally via stdio.
-package copilot
-
-import (
- "context"
- "fmt"
- "sync"
- "time"
-
- "github.com/github/copilot-sdk/go"
- "github.com/kandev/kandev/internal/common/logger"
- "go.uber.org/zap"
-)
-
-// Re-export SDK types for convenience
-type (
- SessionEvent = copilot.SessionEvent
- SessionEventType = copilot.SessionEventType
- SessionConfig = copilot.SessionConfig
- MessageOptions = copilot.MessageOptions
- Data = copilot.Data
- // Permission types
- PermissionHandler = copilot.PermissionHandler
- PermissionRequest = copilot.PermissionRequest
- PermissionInvocation = copilot.PermissionInvocation
- PermissionRequestResult = copilot.PermissionRequestResult
- // MCP types
- MCPServerConfig = copilot.MCPServerConfig
-)
-
-// Re-export event type constants
-const (
- EventTypeSessionStart = copilot.SessionStart
- EventTypeSessionResume = copilot.SessionResume
- EventTypeSessionIdle = copilot.SessionIdle
- EventTypeSessionError = copilot.SessionError
- EventTypeSessionUsageInfo = copilot.SessionUsageInfo
- EventTypeAssistantMessage = copilot.AssistantMessage
- EventTypeAssistantMessageDelta = copilot.AssistantMessageDelta
- EventTypeAssistantReasoning = copilot.AssistantReasoning
- EventTypeAssistantReasoningDelta = copilot.AssistantReasoningDelta
- EventTypeAssistantTurnStart = copilot.AssistantTurnStart
- EventTypeAssistantTurnEnd = copilot.AssistantTurnEnd
- EventTypeAssistantUsage = copilot.AssistantUsage
- EventTypeToolStart = copilot.ToolExecutionStart
- EventTypeToolComplete = copilot.ToolExecutionComplete
- EventTypeToolProgress = copilot.ToolExecutionProgress
- EventTypeAbort = copilot.Abort
-)
-
-// Client wraps the Copilot SDK client with additional functionality.
-type Client struct {
- sdkClient *copilot.Client
- session *copilot.Session
- logger *logger.Logger
-
- // Configuration
- cliURL string
- model string
-
- // Event handler
- eventHandler func(SessionEvent)
- unsubscribe func()
- handlerMu sync.RWMutex
-
- // Permission handler
- permissionHandler PermissionHandler
- permissionMu sync.RWMutex
-
- // State
- sessionID string
- mu sync.RWMutex
- started bool
-}
-
-// ClientConfig holds configuration for creating a Client.
-type ClientConfig struct {
- // CLIUrl is the address of an externally managed Copilot CLI server (e.g. "localhost:12345").
- // When set, the SDK connects via TCP instead of spawning its own process.
- CLIUrl string
- Model string
-}
-
-// NewClient creates a new Copilot client wrapper.
-func NewClient(cfg ClientConfig, log *logger.Logger) *Client {
- if cfg.Model == "" {
- cfg.Model = "gpt-4.1"
- }
-
- return &Client{
- cliURL: cfg.CLIUrl,
- model: cfg.Model,
- logger: log.WithFields(zap.String("component", "copilot-sdk-client")),
- }
-}
-
-// SetEventHandler sets the handler for session events.
-func (c *Client) SetEventHandler(handler func(SessionEvent)) {
- c.handlerMu.Lock()
- defer c.handlerMu.Unlock()
- c.eventHandler = handler
-}
-
-// SetPermissionHandler sets the handler for permission requests.
-func (c *Client) SetPermissionHandler(handler PermissionHandler) {
- c.permissionMu.Lock()
- defer c.permissionMu.Unlock()
- c.permissionHandler = handler
-}
-
-// Start initializes the Copilot SDK client.
-// When CLIUrl is configured, the SDK connects to an external CLI server via TCP.
-// Otherwise, the SDK spawns and manages the CLI process internally via stdio.
-// The actual connection is deferred to the first CreateSession call via AutoStart.
-func (c *Client) Start(ctx context.Context) error {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- if c.started {
- return fmt.Errorf("client already started")
- }
-
- c.logger.Info("starting Copilot SDK client",
- zap.String("model", c.model),
- zap.String("cli_url", c.cliURL))
-
- if c.cliURL != "" {
- // Connect to externally managed CLI server via TCP
- c.sdkClient = copilot.NewClient(&copilot.ClientOptions{
- CLIUrl: c.cliURL,
- LogLevel: "error",
- })
- } else {
- // SDK spawns and manages the CLI process internally (stdio)
- c.sdkClient = copilot.NewClient(nil)
- }
-
- // SDK AutoStart (default: true) defers the actual connection
- // to the first CreateSession call, so no explicit Start() needed.
-
- c.started = true
- c.logger.Info("Copilot SDK client initialized")
-
- return nil
-}
-
-// Stop shuts down the Copilot SDK client.
-func (c *Client) Stop() error {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- if !c.started {
- return nil
- }
-
- c.logger.Info("stopping Copilot SDK client")
-
- // Unsubscribe from events
- c.handlerMu.Lock()
- if c.unsubscribe != nil {
- c.unsubscribe()
- c.unsubscribe = nil
- }
- c.handlerMu.Unlock()
-
- // Destroy session if active
- if c.session != nil {
- if err := c.session.Destroy(); err != nil {
- c.logger.Warn("error destroying session", zap.Error(err))
- }
- c.session = nil
- }
-
- // Stop the SDK client
- if c.sdkClient != nil {
- errs := c.sdkClient.Stop()
- for _, err := range errs {
- c.logger.Warn("error stopping SDK client", zap.Error(err))
- }
- c.sdkClient = nil
- }
-
- c.started = false
- return nil
-}
-
-// CreateSession creates a new Copilot session.
-// mcpServers configures MCP servers for the session (nil if none).
-func (c *Client) CreateSession(ctx context.Context, mcpServers map[string]MCPServerConfig) (string, error) {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- if !c.started {
- return "", fmt.Errorf("client not started")
- }
-
- // Unsubscribe from previous session events
- c.handlerMu.Lock()
- if c.unsubscribe != nil {
- c.unsubscribe()
- c.unsubscribe = nil
- }
- c.handlerMu.Unlock()
-
- // Destroy existing session if any
- if c.session != nil {
- if err := c.session.Destroy(); err != nil {
- c.logger.Warn("error destroying previous session", zap.Error(err))
- }
- c.session = nil
- }
-
- c.logger.Info("creating new session",
- zap.String("model", c.model),
- zap.Int("mcp_servers", len(mcpServers)))
-
- // Get permission handler
- c.permissionMu.RLock()
- permHandler := c.permissionHandler
- c.permissionMu.RUnlock()
-
- // Create session with configuration
- session, err := c.sdkClient.CreateSession(&copilot.SessionConfig{
- Model: c.model,
- Streaming: true,
- OnPermissionRequest: permHandler,
- MCPServers: mcpServers,
- })
- if err != nil {
- return "", fmt.Errorf("failed to create session: %w", err)
- }
-
- // Register event handler BEFORE storing the session so no events are lost
- // between session creation and handler registration.
- c.handlerMu.Lock()
- if c.eventHandler != nil {
- c.unsubscribe = session.On(c.eventHandler)
- }
- c.handlerMu.Unlock()
-
- c.session = session
- c.sessionID = session.SessionID
-
- c.logger.Info("session created", zap.String("session_id", c.sessionID))
-
- return c.sessionID, nil
-}
-
-// ResumeSession resumes an existing session with streaming enabled.
-// mcpServers configures MCP servers for the resumed session (nil if none).
-func (c *Client) ResumeSession(ctx context.Context, sessionID string, mcpServers map[string]MCPServerConfig) error {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- if !c.started {
- return fmt.Errorf("client not started")
- }
-
- // Unsubscribe from previous session events
- c.handlerMu.Lock()
- if c.unsubscribe != nil {
- c.unsubscribe()
- c.unsubscribe = nil
- }
- c.handlerMu.Unlock()
-
- // Destroy existing session if any
- if c.session != nil {
- if err := c.session.Destroy(); err != nil {
- c.logger.Warn("error destroying previous session", zap.Error(err))
- }
- c.session = nil
- }
-
- c.logger.Info("resuming session",
- zap.String("session_id", sessionID),
- zap.Int("mcp_servers", len(mcpServers)))
-
- // Get permission handler
- c.permissionMu.RLock()
- permHandler := c.permissionHandler
- c.permissionMu.RUnlock()
-
- // Use ResumeSessionWithOptions to enable streaming on resumed sessions
- session, err := c.sdkClient.ResumeSessionWithOptions(sessionID, &copilot.ResumeSessionConfig{
- Streaming: true,
- OnPermissionRequest: permHandler,
- MCPServers: mcpServers,
- })
- if err != nil {
- return fmt.Errorf("failed to resume session: %w", err)
- }
-
- // Register event handler BEFORE storing the session so no events are lost.
- c.handlerMu.Lock()
- if c.eventHandler != nil {
- c.unsubscribe = session.On(c.eventHandler)
- }
- c.handlerMu.Unlock()
-
- c.session = session
- c.sessionID = sessionID
-
- c.logger.Info("session resumed", zap.String("session_id", sessionID))
-
- return nil
-}
-
-// Send sends a message to the current session (non-blocking).
-func (c *Client) Send(ctx context.Context, message string) (string, error) {
- c.mu.RLock()
- session := c.session
- c.mu.RUnlock()
-
- if session == nil {
- return "", fmt.Errorf("no active session")
- }
-
- c.logger.Info("sending message to session")
-
- messageID, err := session.Send(copilot.MessageOptions{
- Prompt: message,
- })
- if err != nil {
- return "", fmt.Errorf("failed to send message: %w", err)
- }
-
- return messageID, nil
-}
-
-// SendAndWait sends a message and waits for completion.
-func (c *Client) SendAndWait(ctx context.Context, message string, timeout time.Duration) (*SessionEvent, error) {
- c.mu.RLock()
- session := c.session
- c.mu.RUnlock()
-
- if session == nil {
- return nil, fmt.Errorf("no active session")
- }
-
- if timeout == 0 {
- timeout = 5 * time.Minute
- }
-
- c.logger.Info("sending message and waiting for completion")
-
- result, err := session.SendAndWait(copilot.MessageOptions{
- Prompt: message,
- }, timeout)
- if err != nil {
- return nil, fmt.Errorf("failed to send message: %w", err)
- }
-
- return result, nil
-}
-
-// Abort cancels the current operation.
-func (c *Client) Abort(ctx context.Context) error {
- c.mu.RLock()
- session := c.session
- c.mu.RUnlock()
-
- if session == nil {
- return nil
- }
-
- c.logger.Info("aborting current operation")
- return session.Abort()
-}
-
-// GetSessionID returns the current session ID.
-func (c *Client) GetSessionID() string {
- c.mu.RLock()
- defer c.mu.RUnlock()
- return c.sessionID
-}
-
-// IsStarted returns whether the client has been started.
-func (c *Client) IsStarted() bool {
- c.mu.RLock()
- defer c.mu.RUnlock()
- return c.started
-}
diff --git a/apps/backend/pkg/opencode/client.go b/apps/backend/pkg/opencode/client.go
deleted file mode 100644
index 4bbb0c1f1e..0000000000
--- a/apps/backend/pkg/opencode/client.go
+++ /dev/null
@@ -1,814 +0,0 @@
-package opencode
-
-import (
- "bufio"
- "context"
- "crypto/rand"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "io"
- "net/http"
- "strings"
- "sync"
- "time"
-
- "go.uber.org/zap"
-
- "github.com/kandev/kandev/internal/common/logger"
-)
-
-// SSE reconnection constants
-const (
- sseReconnectBaseDelay = 3 * time.Second
- sseReconnectMaxDelay = 30 * time.Second
- sseMaxRetries = 20
-)
-
-// Client manages HTTP communication with OpenCode server
-type Client struct {
- baseURL string
- directory string
- password string
- httpClient *http.Client
- logger *logger.Logger
-
- // Event handling
- eventHandler EventHandler
- controlCh chan ControlEvent
-
- // SSE connection tracking - prevents multiple concurrent connections
- sseCancel context.CancelFunc
- sseActive bool
- lastEventID string // Last-Event-ID for reconnection
-
- mu sync.RWMutex
- closed bool
-}
-
-// EventHandler is called for each SDK event from the SSE stream
-type EventHandler func(event *SDKEventEnvelope)
-
-// ControlEvent represents control flow events
-type ControlEvent struct {
- Type string // "idle", "auth_required", "session_error", "disconnected"
- Message string
-}
-
-// NewClient creates a new OpenCode HTTP client
-func NewClient(baseURL, directory, password string, log *logger.Logger) *Client {
- return &Client{
- baseURL: strings.TrimSuffix(baseURL, "/"),
- directory: directory,
- password: password,
- httpClient: &http.Client{
- Timeout: 30 * time.Second,
- },
- logger: log,
- controlCh: make(chan ControlEvent, 10),
- }
-}
-
-// GenerateServerPassword generates a cryptographically secure random password
-func GenerateServerPassword() string {
- bytes := make([]byte, 32)
- if _, err := rand.Read(bytes); err != nil {
- // Fallback to a timestamp-based string if random fails
- return fmt.Sprintf("opencode-%d", time.Now().UnixNano())
- }
- return base64.RawURLEncoding.EncodeToString(bytes)
-}
-
-// SetEventHandler sets the handler for SDK events
-func (c *Client) SetEventHandler(handler EventHandler) {
- c.mu.Lock()
- defer c.mu.Unlock()
- c.eventHandler = handler
-}
-
-// ControlChannel returns the channel for control events
-func (c *Client) ControlChannel() <-chan ControlEvent {
- return c.controlCh
-}
-
-// buildAuthHeader creates the Basic auth header value
-func (c *Client) buildAuthHeader() string {
- credentials := base64.StdEncoding.EncodeToString([]byte("opencode:" + c.password))
- return "Basic " + credentials
-}
-
-// doRequest performs an HTTP request with auth headers
-func (c *Client) doRequest(ctx context.Context, method, path string, body io.Reader) (*http.Response, error) {
- url := c.baseURL + path
- if strings.Contains(path, "?") {
- url += "&directory=" + c.directory
- } else {
- url += "?directory=" + c.directory
- }
-
- req, err := http.NewRequestWithContext(ctx, method, url, body)
- if err != nil {
- return nil, fmt.Errorf("create request: %w", err)
- }
-
- req.Header.Set("Authorization", c.buildAuthHeader())
- req.Header.Set("X-OpenCode-Directory", c.directory)
- if body != nil {
- req.Header.Set("Content-Type", "application/json")
- }
-
- return c.httpClient.Do(req)
-}
-
-// doPromptRequest performs an HTTP request with a longer timeout suitable for prompts.
-// Prompts can take minutes to complete, so we use a 60-minute timeout.
-func (c *Client) doPromptRequest(ctx context.Context, method, path string, body io.Reader) (*http.Response, error) {
- url := c.baseURL + path
- if strings.Contains(path, "?") {
- url += "&directory=" + c.directory
- } else {
- url += "?directory=" + c.directory
- }
-
- req, err := http.NewRequestWithContext(ctx, method, url, body)
- if err != nil {
- return nil, fmt.Errorf("create request: %w", err)
- }
-
- req.Header.Set("Authorization", c.buildAuthHeader())
- req.Header.Set("X-OpenCode-Directory", c.directory)
- if body != nil {
- req.Header.Set("Content-Type", "application/json")
- }
-
- // Use a client with extended timeout for prompts
- promptClient := &http.Client{
- Timeout: 60 * time.Minute,
- }
- return promptClient.Do(req)
-}
-
-// WaitForHealth waits for the OpenCode server to be healthy
-func (c *Client) WaitForHealth(ctx context.Context) error {
- deadline := time.Now().Add(20 * time.Second)
- var lastErr error
-
- for time.Now().Before(deadline) {
- select {
- case <-ctx.Done():
- return ctx.Err()
- default:
- }
-
- resp, err := c.doRequest(ctx, http.MethodGet, "/global/health", nil)
- if err != nil {
- lastErr = err
- c.logger.Debug("health check request failed", zap.Error(err))
- time.Sleep(150 * time.Millisecond)
- continue
- }
-
- // Read body for logging and parsing
- bodyBytes, err := io.ReadAll(resp.Body)
- _ = resp.Body.Close()
- if err != nil {
- lastErr = fmt.Errorf("read health response: %w", err)
- time.Sleep(150 * time.Millisecond)
- continue
- }
-
- c.logger.Debug("health check response",
- zap.Int("status", resp.StatusCode),
- zap.String("body", string(bodyBytes)))
-
- // Check HTTP status first
- if resp.StatusCode != http.StatusOK {
- lastErr = fmt.Errorf("health check HTTP %d: %s", resp.StatusCode, string(bodyBytes))
- time.Sleep(150 * time.Millisecond)
- continue
- }
-
- var health HealthResponse
- if err := json.Unmarshal(bodyBytes, &health); err != nil {
- lastErr = fmt.Errorf("parse health response (got: %q): %w", string(bodyBytes), err)
- time.Sleep(150 * time.Millisecond)
- continue
- }
-
- if health.Healthy {
- c.logger.Info("OpenCode server healthy", zap.String("version", health.Version))
- return nil
- }
-
- lastErr = fmt.Errorf("server unhealthy (version %s)", health.Version)
- time.Sleep(150 * time.Millisecond)
- }
-
- if lastErr != nil {
- return fmt.Errorf("health check timeout: %w", lastErr)
- }
- return fmt.Errorf("health check timeout")
-}
-
-// CreateSession creates a new OpenCode session
-func (c *Client) CreateSession(ctx context.Context) (string, error) {
- resp, err := c.doRequest(ctx, http.MethodPost, "/session", strings.NewReader("{}"))
- if err != nil {
- return "", fmt.Errorf("create session request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
- body, _ := io.ReadAll(resp.Body)
- return "", fmt.Errorf("create session failed: HTTP %d: %s", resp.StatusCode, string(body))
- }
-
- var session SessionResponse
- if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {
- return "", fmt.Errorf("parse session response: %w", err)
- }
-
- return session.ID, nil
-}
-
-// ForkSession forks an existing session for follow-up prompts
-func (c *Client) ForkSession(ctx context.Context, sessionID string) (string, error) {
- path := fmt.Sprintf("/session/%s/fork", sessionID)
- resp, err := c.doRequest(ctx, http.MethodPost, path, strings.NewReader("{}"))
- if err != nil {
- return "", fmt.Errorf("fork session request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
- body, _ := io.ReadAll(resp.Body)
- return "", fmt.Errorf("fork session failed: HTTP %d: %s", resp.StatusCode, string(body))
- }
-
- var session SessionResponse
- if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {
- return "", fmt.Errorf("parse session response: %w", err)
- }
-
- return session.ID, nil
-}
-
-// SendPrompt sends a prompt to the session.
-// This call blocks until OpenCode finishes processing the prompt.
-func (c *Client) SendPrompt(ctx context.Context, sessionID, prompt string, model *ModelSpec, agent, variant string) error {
- req := PromptRequest{
- Model: model,
- Agent: agent,
- Variant: variant,
- Parts: []TextPartInput{
- {Type: "text", Text: prompt},
- },
- }
-
- body, err := json.Marshal(req)
- if err != nil {
- return fmt.Errorf("marshal prompt request: %w", err)
- }
-
- c.logger.Debug("sending prompt HTTP request",
- zap.String("session_id", sessionID),
- zap.Int("body_len", len(body)))
-
- path := fmt.Sprintf("/session/%s/message", sessionID)
- resp, err := c.doPromptRequest(ctx, http.MethodPost, path, strings.NewReader(string(body)))
- if err != nil {
- return fmt.Errorf("send prompt request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- respBody, err := io.ReadAll(resp.Body)
- if err != nil {
- return fmt.Errorf("read prompt response: %w", err)
- }
-
- c.logger.Debug("prompt HTTP response received",
- zap.Int("status", resp.StatusCode),
- zap.Int("body_len", len(respBody)))
-
- if resp.StatusCode != http.StatusOK {
- return fmt.Errorf("prompt failed: HTTP %d: %s", resp.StatusCode, string(respBody))
- }
-
- trimmed := strings.TrimSpace(string(respBody))
- if trimmed == "" {
- return fmt.Errorf("prompt returned empty response")
- }
-
- var parsed map[string]any
- if err := json.Unmarshal([]byte(trimmed), &parsed); err != nil {
- return fmt.Errorf("parse prompt response: %w", err)
- }
-
- if _, hasInfo := parsed["info"]; hasInfo {
- if _, hasParts := parsed["parts"]; hasParts {
- return nil
- }
- }
-
- if name, ok := parsed["name"].(string); ok {
- message := "unknown error"
- if data, ok := parsed["data"].(map[string]any); ok {
- if msg, ok := data["message"].(string); ok {
- message = msg
- }
- }
- return fmt.Errorf("prompt error: %s: %s", name, message)
- }
-
- return nil
-}
-
-// Abort sends an abort request to stop the current operation
-func (c *Client) Abort(ctx context.Context, sessionID string) error {
- path := fmt.Sprintf("/session/%s/abort", sessionID)
-
- // Use a short timeout for abort
- abortCtx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
- defer cancel()
-
- resp, err := c.doRequest(abortCtx, http.MethodPost, path, nil)
- if err != nil {
- return nil // Ignore abort errors
- }
- defer func() { _ = resp.Body.Close() }()
-
- // Drain body
- _, _ = io.ReadAll(resp.Body)
- return nil
-}
-
-// ReplyPermission sends a permission reply
-func (c *Client) ReplyPermission(ctx context.Context, requestID, reply string, message *string) error {
- payload := PermissionReplyRequest{
- Reply: reply,
- }
- if message != nil {
- payload.Message = *message
- } else if reply == PermissionReplyReject {
- // If rejecting without message, provide default
- payload.Message = "User denied this tool use request"
- }
-
- body, err := json.Marshal(payload)
- if err != nil {
- return fmt.Errorf("marshal permission reply: %w", err)
- }
-
- path := fmt.Sprintf("/permission/%s/reply", requestID)
- resp, err := c.doRequest(ctx, http.MethodPost, path, strings.NewReader(string(body)))
- if err != nil {
- return fmt.Errorf("permission reply request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- // Drain body
- _, _ = io.ReadAll(resp.Body)
- return nil
-}
-
-// Summarize triggers compaction/summarization for a session.
-func (c *Client) Summarize(ctx context.Context, sessionID string, model *ModelSpec) error {
- payload := map[string]any{}
- if model != nil {
- payload["model"] = model
- }
-
- body, err := json.Marshal(payload)
- if err != nil {
- return fmt.Errorf("marshal summarize request: %w", err)
- }
-
- path := fmt.Sprintf("/session/%s/summarize", sessionID)
- resp, err := c.doPromptRequest(ctx, http.MethodPost, path, strings.NewReader(string(body)))
- if err != nil {
- return fmt.Errorf("summarize request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK {
- respBody, _ := io.ReadAll(resp.Body)
- return fmt.Errorf("summarize failed: HTTP %d: %s", resp.StatusCode, string(respBody))
- }
- _, _ = io.ReadAll(resp.Body)
- return nil
-}
-
-// ListProviders fetches provider information including model context windows.
-func (c *Client) ListProviders(ctx context.Context) (*ProviderListResponse, error) {
- resp, err := c.doRequest(ctx, http.MethodGet, "/provider", nil)
- if err != nil {
- return nil, fmt.Errorf("list providers request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK {
- body, _ := io.ReadAll(resp.Body)
- return nil, fmt.Errorf("list providers failed: HTTP %d: %s", resp.StatusCode, string(body))
- }
-
- var result ProviderListResponse
- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
- return nil, fmt.Errorf("parse providers response: %w", err)
- }
- return &result, nil
-}
-
-// ListCommands fetches available slash commands from the server.
-func (c *Client) ListCommands(ctx context.Context) ([]CommandInfo, error) {
- resp, err := c.doRequest(ctx, http.MethodGet, "/command", nil)
- if err != nil {
- return nil, fmt.Errorf("list commands request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK {
- body, _ := io.ReadAll(resp.Body)
- return nil, fmt.Errorf("list commands failed: HTTP %d: %s", resp.StatusCode, string(body))
- }
-
- var result []CommandInfo
- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
- return nil, fmt.Errorf("parse commands response: %w", err)
- }
- return result, nil
-}
-
-// RunSessionCommand executes a slash command in a session.
-func (c *Client) RunSessionCommand(ctx context.Context, sessionID, command string) error {
- payload := map[string]string{"command": command}
- body, err := json.Marshal(payload)
- if err != nil {
- return fmt.Errorf("marshal command request: %w", err)
- }
-
- path := fmt.Sprintf("/session/%s/command", sessionID)
- resp, err := c.doPromptRequest(ctx, http.MethodPost, path, strings.NewReader(string(body)))
- if err != nil {
- return fmt.Errorf("run command request: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK {
- respBody, _ := io.ReadAll(resp.Body)
- return fmt.Errorf("run command failed: HTTP %d: %s", resp.StatusCode, string(respBody))
- }
- _, _ = io.ReadAll(resp.Body)
- return nil
-}
-
-// StartEventStream starts the SSE event stream and processes events.
-// It ensures only one SSE connection is active at a time to prevent duplicate events.
-// Supports automatic reconnection with Last-Event-ID for event resumption.
-func (c *Client) StartEventStream(ctx context.Context, sessionID string) error {
- c.mu.Lock()
- if c.sseActive {
- c.mu.Unlock()
- c.logger.Debug("SSE stream already active, skipping duplicate connection",
- zap.String("session_id", sessionID))
- return nil
- }
- c.sseActive = true
- c.mu.Unlock()
-
- sseCtx, sseCancel := context.WithCancel(ctx)
-
- c.mu.Lock()
- c.sseCancel = sseCancel
- c.mu.Unlock()
-
- // Connect and start processing with reconnect support
- if err := c.connectSSE(sseCtx, sessionID); err != nil {
- c.mu.Lock()
- c.sseActive = false
- c.sseCancel = nil
- c.mu.Unlock()
- sseCancel()
- return err
- }
-
- return nil
-}
-
-// connectSSE establishes the SSE connection and starts the event loop.
-func (c *Client) connectSSE(ctx context.Context, sessionID string) error {
- resp, err := c.dialSSE(ctx)
- if err != nil {
- return err
- }
- c.logger.Debug("SSE stream connected", zap.String("session_id", sessionID))
- go c.sseEventLoop(ctx, sessionID, resp.Body)
- return nil
-}
-
-// dialSSE creates and executes an SSE HTTP request, including Last-Event-ID if available.
-func (c *Client) dialSSE(ctx context.Context) (*http.Response, error) {
- url := c.baseURL + "/event?directory=" + c.directory
-
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
- if err != nil {
- return nil, fmt.Errorf("create event stream request: %w", err)
- }
-
- req.Header.Set("Authorization", c.buildAuthHeader())
- req.Header.Set("X-OpenCode-Directory", c.directory)
- req.Header.Set("Accept", "text/event-stream")
-
- c.mu.RLock()
- lastID := c.lastEventID
- c.mu.RUnlock()
- if lastID != "" {
- req.Header.Set("Last-Event-ID", lastID)
- }
-
- sseClient := &http.Client{}
- resp, err := sseClient.Do(req)
- if err != nil {
- return nil, fmt.Errorf("connect event stream: %w", err)
- }
-
- if resp.StatusCode != http.StatusOK {
- body, _ := io.ReadAll(resp.Body)
- _ = resp.Body.Close()
- return nil, fmt.Errorf("event stream failed: HTTP %d: %s", resp.StatusCode, string(body))
- }
-
- return resp, nil
-}
-
-// sseEventLoop reads SSE events, dispatches them, and reconnects on disconnect.
-func (c *Client) sseEventLoop(ctx context.Context, sessionID string, body io.ReadCloser) {
- defer func() {
- c.mu.Lock()
- c.sseActive = false
- c.sseCancel = nil
- c.mu.Unlock()
- }()
-
- for attempt := 0; ; attempt++ {
- disconnectReason := c.readSSEStream(ctx, sessionID, body)
- _ = body.Close()
-
- if disconnectReason == sseDisconnectCancelled || disconnectReason == sseDisconnectClosed {
- return
- }
-
- // Attempt reconnection with exponential backoff
- if attempt >= sseMaxRetries {
- c.logger.Warn("SSE max retries reached, giving up",
- zap.Int("retries", attempt))
- c.sendControlEvent("disconnected")
- return
- }
-
- delay := sseBackoff(attempt)
- c.logger.Info("SSE stream disconnected, reconnecting",
- zap.Int("attempt", attempt+1),
- zap.Duration("delay", delay))
-
- select {
- case <-ctx.Done():
- return
- case <-time.After(delay):
- }
-
- resp, err := c.dialSSE(ctx)
- if err != nil {
- c.logger.Warn("SSE reconnect failed", zap.Error(err), zap.Int("attempt", attempt+1))
- continue
- }
-
- body = resp.Body
- c.logger.Info("SSE stream reconnected", zap.Int("attempt", attempt+1))
- }
-}
-
-// sseDisconnectReason indicates why the SSE stream ended.
-type sseDisconnectReason int
-
-const (
- sseDisconnectError sseDisconnectReason = iota // network/scan error, should reconnect
- sseDisconnectCancelled // context cancelled, no reconnect
- sseDisconnectClosed // client closed, no reconnect
-)
-
-// readSSEStream reads events from a single SSE connection until it ends.
-func (c *Client) readSSEStream(ctx context.Context, sessionID string, body io.Reader) sseDisconnectReason {
- scanner := bufio.NewScanner(body)
- buf := make([]byte, 0, 64*1024)
- scanner.Buffer(buf, 1024*1024)
-
- var dataBuffer strings.Builder
- var currentID string
-
- for scanner.Scan() {
- select {
- case <-ctx.Done():
- return sseDisconnectCancelled
- default:
- }
-
- line := scanner.Text()
-
- // Track event ID for reconnection
- if strings.HasPrefix(line, "id: ") {
- currentID = strings.TrimPrefix(line, "id: ")
- continue
- }
-
- if strings.HasPrefix(line, "data: ") {
- dataBuffer.WriteString(strings.TrimPrefix(line, "data: "))
- continue
- }
-
- if line == "" && dataBuffer.Len() > 0 {
- data := strings.TrimSpace(dataBuffer.String())
- dataBuffer.Reset()
-
- // Update Last-Event-ID
- if currentID != "" {
- c.mu.Lock()
- c.lastEventID = currentID
- c.mu.Unlock()
- currentID = ""
- }
-
- if data == "" {
- continue
- }
-
- c.dispatchSSEEvent(data, sessionID)
- }
- }
-
- if err := scanner.Err(); err != nil {
- c.logger.Error("event stream error", zap.Error(err))
- }
-
- c.mu.RLock()
- closed := c.closed
- c.mu.RUnlock()
- if closed {
- return sseDisconnectClosed
- }
- return sseDisconnectError
-}
-
-// dispatchSSEEvent parses and dispatches a single SSE event.
-func (c *Client) dispatchSSEEvent(data, sessionID string) {
- event, err := ParseSDKEvent([]byte(data))
- if err != nil {
- c.logger.Warn("failed to parse SDK event", zap.Error(err))
- return
- }
-
- c.logger.Debug("SSE event received",
- zap.String("type", event.Type),
- zap.String("session_id", sessionID))
-
- if !c.eventMatchesSession(event, sessionID) {
- c.logger.Debug("SSE event filtered (session mismatch)", zap.String("type", event.Type))
- return
- }
-
- c.processControlEvent(event, sessionID)
-
- c.mu.RLock()
- handler := c.eventHandler
- c.mu.RUnlock()
-
- if handler != nil {
- handler(event)
- }
-}
-
-// sendControlEvent sends a control event if the client is not closed.
-func (c *Client) sendControlEvent(eventType string) {
- c.mu.RLock()
- closed := c.closed
- c.mu.RUnlock()
- if !closed {
- select {
- case c.controlCh <- ControlEvent{Type: eventType}:
- default:
- }
- }
-}
-
-// sseBackoff computes exponential backoff delay for SSE reconnection.
-func sseBackoff(attempt int) time.Duration {
- delay := sseReconnectBaseDelay
- for i := 0; i < attempt; i++ {
- delay *= 2
- if delay > sseReconnectMaxDelay {
- delay = sseReconnectMaxDelay
- break
- }
- }
- return delay
-}
-
-// eventMatchesSession checks if an event belongs to the specified session
-func (c *Client) eventMatchesSession(event *SDKEventEnvelope, sessionID string) bool {
- // Try to extract sessionID from properties
- var props map[string]any
- if event.Properties != nil {
- if err := json.Unmarshal(event.Properties, &props); err != nil {
- return true // If we can't parse, let it through
- }
- }
-
- // Check various paths where sessionID might be
- extractedID := ""
-
- switch event.Type {
- case SDKEventMessageUpdated:
- if info, ok := props["info"].(map[string]any); ok {
- if id, ok := info["sessionID"].(string); ok {
- extractedID = id
- }
- }
- case SDKEventMessagePartUpdated:
- if part, ok := props["part"].(map[string]any); ok {
- if id, ok := part["sessionID"].(string); ok {
- extractedID = id
- }
- }
- default:
- if id, ok := props["sessionID"].(string); ok {
- extractedID = id
- }
- }
-
- if extractedID == "" {
- return true // No sessionID in event, let it through
- }
-
- return extractedID == sessionID
-}
-
-// processControlEvent handles control flow events
-func (c *Client) processControlEvent(event *SDKEventEnvelope, sessionID string) {
- // Check if closed first to avoid panic on closed channel
- c.mu.RLock()
- closed := c.closed
- c.mu.RUnlock()
- if closed {
- return
- }
-
- switch event.Type {
- case SDKEventSessionIdle:
- select {
- case c.controlCh <- ControlEvent{Type: "idle"}:
- default:
- }
-
- case SDKEventSessionError:
- props, err := ParseSessionError(event.Properties)
- if err != nil {
- return
- }
-
- if props.Error != nil {
- kind := props.Error.GetKind()
- message := props.Error.GetMessage()
-
- if kind == "ProviderAuthError" {
- select {
- case c.controlCh <- ControlEvent{Type: "auth_required", Message: message}:
- default:
- }
- } else {
- select {
- case c.controlCh <- ControlEvent{Type: "session_error", Message: message}:
- default:
- }
- }
- }
- }
-}
-
-// Close closes the client and terminates any active SSE connection
-func (c *Client) Close() {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- if c.closed {
- return
- }
- c.closed = true
-
- // Cancel any active SSE connection
- if c.sseCancel != nil {
- c.sseCancel()
- c.sseCancel = nil
- }
- c.sseActive = false
-
- close(c.controlCh)
-}
diff --git a/apps/backend/pkg/opencode/client_test.go b/apps/backend/pkg/opencode/client_test.go
deleted file mode 100644
index abeae2fb01..0000000000
--- a/apps/backend/pkg/opencode/client_test.go
+++ /dev/null
@@ -1,465 +0,0 @@
-package opencode
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "net/http"
- "net/http/httptest"
- "strings"
- "testing"
- "time"
-
- "github.com/kandev/kandev/internal/common/logger"
-)
-
-func newTestLogger() *logger.Logger {
- log, _ := logger.NewLogger(logger.LoggingConfig{
- Level: "error",
- Format: "json",
- })
- return log
-}
-
-func TestGenerateServerPassword(t *testing.T) {
- // Generate multiple passwords and ensure they're unique
- passwords := make(map[string]bool)
- for i := 0; i < 10; i++ {
- pw := GenerateServerPassword()
- if pw == "" {
- t.Error("generated empty password")
- }
- if passwords[pw] {
- t.Error("generated duplicate password")
- }
- passwords[pw] = true
- }
-}
-
-func TestClient_BuildAuthHeader(t *testing.T) {
- client := NewClient("http://localhost:8080", "/workspace", "test-password", newTestLogger())
-
- header := client.buildAuthHeader()
- if !strings.HasPrefix(header, "Basic ") {
- t.Errorf("expected header to start with 'Basic ', got %s", header)
- }
-}
-
-func TestClient_WaitForHealth(t *testing.T) {
- tests := []struct {
- name string
- responses []HealthResponse
- delays []time.Duration
- wantError bool
- }{
- {
- name: "healthy immediately",
- responses: []HealthResponse{{Healthy: true, Version: "1.0.0"}},
- delays: []time.Duration{0},
- wantError: false,
- },
- {
- name: "healthy after retry",
- responses: []HealthResponse{
- {Healthy: false, Version: "1.0.0"},
- {Healthy: true, Version: "1.0.0"},
- },
- delays: []time.Duration{0, 0},
- wantError: false,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- callCount := 0
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if !strings.HasPrefix(r.URL.Path, "/global/health") {
- http.Error(w, "not found", http.StatusNotFound)
- return
- }
-
- if callCount < len(tt.delays) {
- time.Sleep(tt.delays[callCount])
- }
-
- resp := tt.responses[callCount%len(tt.responses)]
- callCount++
-
- w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(resp)
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
-
- err := client.WaitForHealth(ctx)
- if tt.wantError && err == nil {
- t.Error("expected error, got nil")
- }
- if !tt.wantError && err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- })
- }
-}
-
-func TestClient_CreateSession(t *testing.T) {
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodPost {
- http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
- return
- }
- if !strings.Contains(r.URL.Path, "/session") {
- http.Error(w, "not found", http.StatusNotFound)
- return
- }
-
- // Check auth header
- auth := r.Header.Get("Authorization")
- if !strings.HasPrefix(auth, "Basic ") {
- http.Error(w, "unauthorized", http.StatusUnauthorized)
- return
- }
-
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(http.StatusOK)
- _ = json.NewEncoder(w).Encode(SessionResponse{ID: "sess-123"})
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- sessionID, err := client.CreateSession(ctx)
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if sessionID != "sess-123" {
- t.Errorf("expected session ID 'sess-123', got %s", sessionID)
- }
-}
-
-func TestClient_ForkSession(t *testing.T) {
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodPost {
- http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
- return
- }
- if !strings.Contains(r.URL.Path, "/session/sess-123/fork") {
- http.Error(w, "not found", http.StatusNotFound)
- return
- }
-
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(http.StatusOK)
- _ = json.NewEncoder(w).Encode(SessionResponse{ID: "sess-456"})
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- newSessionID, err := client.ForkSession(ctx, "sess-123")
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if newSessionID != "sess-456" {
- t.Errorf("expected session ID 'sess-456', got %s", newSessionID)
- }
-}
-
-func TestClient_SendPrompt(t *testing.T) {
- tests := []struct {
- name string
- statusCode int
- response string
- wantError bool
- }{
- {
- name: "success",
- statusCode: http.StatusOK,
- response: `{"info":{},"parts":[]}`,
- wantError: false,
- },
- {
- name: "error response",
- statusCode: http.StatusOK,
- response: `{"name":"SomeError","data":{"message":"something went wrong"}}`,
- wantError: true,
- },
- {
- name: "http error",
- statusCode: http.StatusInternalServerError,
- response: `{"error":"internal error"}`,
- wantError: true,
- },
- {
- name: "empty response",
- statusCode: http.StatusOK,
- response: ``,
- wantError: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(tt.statusCode)
- _, _ = fmt.Fprint(w, tt.response)
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- err := client.SendPrompt(ctx, "sess-123", "Hello", nil, "", "")
- if tt.wantError && err == nil {
- t.Error("expected error, got nil")
- }
- if !tt.wantError && err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- })
- }
-}
-
-func TestClient_SendPrompt_WithModel(t *testing.T) {
- var receivedBody PromptRequest
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- _ = json.NewDecoder(r.Body).Decode(&receivedBody)
- w.Header().Set("Content-Type", "application/json")
- _, _ = fmt.Fprint(w, `{"info":{},"parts":[]}`)
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- model := &ModelSpec{ProviderID: "anthropic", ModelID: "claude-3-sonnet"}
- err := client.SendPrompt(ctx, "sess-123", "Hello", model, "coder", "default")
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if receivedBody.Model == nil {
- t.Error("expected model to be set")
- } else if receivedBody.Model.ProviderID != "anthropic" {
- t.Errorf("expected providerID 'anthropic', got %s", receivedBody.Model.ProviderID)
- }
- if receivedBody.Agent != "coder" {
- t.Errorf("expected agent 'coder', got %s", receivedBody.Agent)
- }
- if receivedBody.Variant != "default" {
- t.Errorf("expected variant 'default', got %s", receivedBody.Variant)
- }
-}
-
-func TestClient_Abort(t *testing.T) {
- aborted := false
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if r.Method == http.MethodPost && strings.Contains(r.URL.Path, "/abort") {
- aborted = true
- w.WriteHeader(http.StatusOK)
- return
- }
- http.Error(w, "not found", http.StatusNotFound)
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- err := client.Abort(ctx, "sess-123")
- if err != nil {
- t.Errorf("unexpected error: %v", err)
- }
- if !aborted {
- t.Error("expected abort endpoint to be called")
- }
-}
-
-func TestClient_ReplyPermission(t *testing.T) {
- tests := []struct {
- name string
- reply string
- message *string
- }{
- {
- name: "allow once",
- reply: PermissionReplyOnce,
- message: nil,
- },
- {
- name: "reject with message",
- reply: PermissionReplyReject,
- message: strPtr("User denied"),
- },
- {
- name: "reject without message",
- reply: PermissionReplyReject,
- message: nil,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var receivedBody PermissionReplyRequest
- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- _ = json.NewDecoder(r.Body).Decode(&receivedBody)
- w.WriteHeader(http.StatusOK)
- }))
- defer server.Close()
-
- client := NewClient(server.URL, "/workspace", "test-password", newTestLogger())
- ctx := context.Background()
-
- err := client.ReplyPermission(ctx, "perm-123", tt.reply, tt.message)
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if receivedBody.Reply != tt.reply {
- t.Errorf("expected reply %s, got %s", tt.reply, receivedBody.Reply)
- }
-
- if tt.message != nil {
- if receivedBody.Message != *tt.message {
- t.Errorf("expected message %s, got %s", *tt.message, receivedBody.Message)
- }
- } else if tt.reply == PermissionReplyReject {
- // Should have default message
- if receivedBody.Message == "" {
- t.Error("expected default message for reject without message")
- }
- }
- })
- }
-}
-
-func TestClient_ControlChannel(t *testing.T) {
- client := NewClient("http://localhost:8080", "/workspace", "test-password", newTestLogger())
-
- ch := client.ControlChannel()
- if ch == nil {
- t.Error("expected control channel to be non-nil")
- }
-}
-
-func TestClient_SetEventHandler(t *testing.T) {
- client := NewClient("http://localhost:8080", "/workspace", "test-password", newTestLogger())
-
- handler := func(event *SDKEventEnvelope) {
- // Handler logic
- }
-
- client.SetEventHandler(handler)
-
- // Access handler through the client - this is internal but we can test it works
- client.mu.RLock()
- h := client.eventHandler
- client.mu.RUnlock()
-
- if h == nil {
- t.Error("expected event handler to be set")
- }
-}
-
-func TestClient_Close(t *testing.T) {
- client := NewClient("http://localhost:8080", "/workspace", "test-password", newTestLogger())
-
- // First close should succeed
- client.Close()
-
- // Second close should be a no-op
- client.Close()
-
- // Client should be marked as closed
- client.mu.RLock()
- closed := client.closed
- client.mu.RUnlock()
-
- if !closed {
- t.Error("expected client to be closed")
- }
-}
-
-func TestClient_EventMatchesSession(t *testing.T) {
- client := NewClient("http://localhost:8080", "/workspace", "test-password", newTestLogger())
-
- tests := []struct {
- name string
- eventType string
- props string
- sessionID string
- want bool
- }{
- {
- name: "message.updated matches",
- eventType: SDKEventMessageUpdated,
- props: `{"info":{"sessionID":"sess-123"}}`,
- sessionID: "sess-123",
- want: true,
- },
- {
- name: "message.updated doesn't match",
- eventType: SDKEventMessageUpdated,
- props: `{"info":{"sessionID":"sess-456"}}`,
- sessionID: "sess-123",
- want: false,
- },
- {
- name: "message.part.updated matches",
- eventType: SDKEventMessagePartUpdated,
- props: `{"part":{"sessionID":"sess-123"}}`,
- sessionID: "sess-123",
- want: true,
- },
- {
- name: "other event matches",
- eventType: SDKEventSessionIdle,
- props: `{"sessionID":"sess-123"}`,
- sessionID: "sess-123",
- want: true,
- },
- {
- name: "no sessionID in event - matches",
- eventType: SDKEventSessionIdle,
- props: `{}`,
- sessionID: "sess-123",
- want: true,
- },
- {
- name: "nil properties - matches",
- eventType: SDKEventSessionIdle,
- props: "",
- sessionID: "sess-123",
- want: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var props json.RawMessage
- if tt.props != "" {
- props = json.RawMessage(tt.props)
- }
-
- event := &SDKEventEnvelope{
- Type: tt.eventType,
- Properties: props,
- }
-
- got := client.eventMatchesSession(event, tt.sessionID)
- if got != tt.want {
- t.Errorf("expected %v, got %v", tt.want, got)
- }
- })
- }
-}
-
-func strPtr(s string) *string {
- return &s
-}
diff --git a/apps/backend/pkg/opencode/types.go b/apps/backend/pkg/opencode/types.go
deleted file mode 100644
index 5dcce152a9..0000000000
--- a/apps/backend/pkg/opencode/types.go
+++ /dev/null
@@ -1,365 +0,0 @@
-// Package opencode provides types and client for the OpenCode CLI protocol.
-// OpenCode uses a REST API + Server-Sent Events (SSE) pattern for communication.
-package opencode
-
-import (
- "encoding/json"
-)
-
-// ExecutorEvent types written to adapter output
-const (
- EventTypeStartupLog = "startup_log"
- EventTypeSessionStart = "session_start"
- EventTypeSDKEvent = "sdk_event"
- EventTypeTokenUsage = "token_usage"
- EventTypeApprovalResponse = "approval_response"
- EventTypeError = "error"
- EventTypeDone = "done"
-)
-
-// SDK Event types from /event SSE stream
-const (
- SDKEventMessageUpdated = "message.updated"
- SDKEventMessagePartUpdated = "message.part.updated"
- SDKEventMessageRemoved = "message.removed"
- SDKEventMessagePartRemoved = "message.part.removed"
- SDKEventPermissionAsked = "permission.asked"
- SDKEventPermissionReplied = "permission.replied"
- SDKEventSessionIdle = "session.idle"
- SDKEventSessionStatus = "session.status"
- SDKEventSessionDiff = "session.diff"
- SDKEventSessionCompacted = "session.compacted"
- SDKEventSessionError = "session.error"
- SDKEventTodoUpdated = "todo.updated"
-)
-
-// Part types
-const (
- PartTypeText = "text"
- PartTypeReasoning = "reasoning"
- PartTypeTool = "tool"
-)
-
-// Tool status values
-const (
- ToolStatusPending = "pending"
- ToolStatusRunning = "running"
- ToolStatusCompleted = "completed"
- ToolStatusError = "error"
-)
-
-// Permission reply values
-const (
- PermissionReplyOnce = "once"
- PermissionReplyReject = "reject"
-)
-
-// ExecutorEvent represents events written to stdout by the adapter
-type ExecutorEvent struct {
- Type string `json:"type"`
- // Variant fields based on type
- Message string `json:"message,omitempty"`
- SessionID string `json:"session_id,omitempty"`
- Event json.RawMessage `json:"event,omitempty"`
- TotalTokens int `json:"total_tokens,omitempty"`
- ModelContextWindow int `json:"model_context_window,omitempty"`
- ToolCallID string `json:"tool_call_id,omitempty"`
- Status string `json:"status,omitempty"`
-}
-
-// HealthResponse from GET /global/health
-type HealthResponse struct {
- Healthy bool `json:"healthy"`
- Version string `json:"version"`
-}
-
-// SessionResponse from POST /session or POST /session/{id}/fork
-type SessionResponse struct {
- ID string `json:"id"`
-}
-
-// ModelSpec for prompt requests
-type ModelSpec struct {
- ProviderID string `json:"providerID"`
- ModelID string `json:"modelID"`
-}
-
-// TextPartInput for prompt request parts
-type TextPartInput struct {
- Type string `json:"type"`
- Text string `json:"text"`
-}
-
-// PromptRequest for POST /session/{id}/message
-type PromptRequest struct {
- Model *ModelSpec `json:"model,omitempty"`
- Agent string `json:"agent,omitempty"`
- Variant string `json:"variant,omitempty"`
- Parts []TextPartInput `json:"parts"`
-}
-
-// PermissionReplyRequest for POST /permission/{id}/reply
-type PermissionReplyRequest struct {
- Reply string `json:"reply"`
- Message string `json:"message,omitempty"`
-}
-
-// SDKEventEnvelope is the base structure for all SSE events
-type SDKEventEnvelope struct {
- Type string `json:"type"`
- Properties json.RawMessage `json:"properties,omitempty"`
-}
-
-// MessageUpdatedProperties for message.updated events
-type MessageUpdatedProperties struct {
- Info MessageInfo `json:"info"`
-}
-
-// MessageInfo contains message metadata
-type MessageInfo struct {
- ID string `json:"id"`
- SessionID string `json:"sessionID"`
- Role string `json:"role"` // "user", "assistant"
- Model *MessageModelInfo `json:"model,omitempty"`
- ProviderID string `json:"providerID,omitempty"`
- ModelID string `json:"modelID,omitempty"`
- Tokens *MessageTokensInfo `json:"tokens,omitempty"`
-}
-
-// MessageModelInfo contains model information
-type MessageModelInfo struct {
- ProviderID string `json:"providerID"`
- ModelID string `json:"modelID"`
-}
-
-// MessageTokensInfo contains token usage information
-type MessageTokensInfo struct {
- Input int `json:"input"`
- Output int `json:"output"`
- Cache *MessageTokensCacheInfo `json:"cache,omitempty"`
-}
-
-// MessageTokensCacheInfo contains cache token information
-type MessageTokensCacheInfo struct {
- Read int `json:"read"`
-}
-
-// MessagePartUpdatedProperties for message.part.updated events
-type MessagePartUpdatedProperties struct {
- Part Part `json:"part"`
- Delta string `json:"delta,omitempty"`
-}
-
-// Part represents a message part (text, reasoning, or tool)
-type Part struct {
- ID string `json:"id"` // Unique part identifier for tracking updates
- Type string `json:"type"` // "text", "reasoning", "tool"
- MessageID string `json:"messageID"`
- SessionID string `json:"sessionID"`
- Text string `json:"text,omitempty"` // For text/reasoning
- CallID string `json:"callID,omitempty"` // For tool
- Tool string `json:"tool,omitempty"` // For tool
- State *ToolStateUpdate `json:"state,omitempty"` // For tool
-}
-
-// ToolStateUpdate represents tool execution state
-type ToolStateUpdate struct {
- Status string `json:"status"` // "pending", "running", "completed", "error"
- Input json.RawMessage `json:"input,omitempty"`
- Output string `json:"output,omitempty"`
- Title string `json:"title,omitempty"`
- Error string `json:"error,omitempty"`
- Metadata json.RawMessage `json:"metadata,omitempty"`
-}
-
-// PermissionAskedProperties for permission.asked events
-type PermissionAskedProperties struct {
- ID string `json:"id"`
- SessionID string `json:"sessionID"`
- Permission string `json:"permission"`
- Patterns []string `json:"patterns,omitempty"`
- Metadata map[string]any `json:"metadata,omitempty"`
- Tool *PermissionToolInfo `json:"tool,omitempty"`
-}
-
-// PermissionToolInfo contains tool information for permission requests
-type PermissionToolInfo struct {
- CallID string `json:"callID"`
-}
-
-// SessionIdleProperties for session.idle events
-type SessionIdleProperties struct {
- SessionID string `json:"sessionID"`
-}
-
-// SessionErrorProperties for session.error events
-type SessionErrorProperties struct {
- SessionID string `json:"sessionID"`
- Error *SDKError `json:"error,omitempty"`
-}
-
-// SDKError represents an error from the SDK
-type SDKError struct {
- Name string `json:"name,omitempty"`
- Type string `json:"type,omitempty"`
- Message string `json:"message,omitempty"`
- Data *struct {
- Message string `json:"message,omitempty"`
- } `json:"data,omitempty"`
-}
-
-// GetMessage returns the error message
-func (e *SDKError) GetMessage() string {
- if e.Data != nil && e.Data.Message != "" {
- return e.Data.Message
- }
- return e.Message
-}
-
-// GetKind returns the error kind/type
-func (e *SDKError) GetKind() string {
- if e.Name != "" {
- return e.Name
- }
- if e.Type != "" {
- return e.Type
- }
- return "unknown"
-}
-
-// SessionStatusProperties for session.status events
-type SessionStatusProperties struct {
- Status SessionStatus `json:"status"`
-}
-
-// SessionStatus represents session status
-type SessionStatus struct {
- Type string `json:"type"` // "idle", "busy", "retry"
- Attempt int `json:"attempt,omitempty"`
- Message string `json:"message,omitempty"`
- Next int64 `json:"next,omitempty"`
-}
-
-// TodoUpdatedProperties for todo.updated events
-type TodoUpdatedProperties struct {
- Todos []SDKTodo `json:"todos"`
-}
-
-// SDKTodo represents a todo item
-type SDKTodo struct {
- ID string `json:"id"`
- Content string `json:"content"`
- Status string `json:"status"`
- Priority string `json:"priority"`
-}
-
-// CommandInfo represents a slash command from GET /command.
-type CommandInfo struct {
- Name string `json:"name"`
- Description string `json:"description,omitempty"`
- // Some commands have structured input
- Input *CommandInputInfo `json:"input,omitempty"`
-}
-
-// CommandInputInfo describes command input expectations.
-type CommandInputInfo struct {
- Hint string `json:"hint,omitempty"`
-}
-
-// ProviderListResponse from GET /provider
-type ProviderListResponse struct {
- All []ProviderInfo `json:"all"`
-}
-
-// ProviderInfo contains provider information
-type ProviderInfo struct {
- ID string `json:"id"`
- Models map[string]ProviderModelInfo `json:"models,omitempty"`
-}
-
-// ProviderModelInfo contains model information from provider
-type ProviderModelInfo struct {
- Limit ProviderModelLimit `json:"limit"`
-}
-
-// ProviderModelLimit contains model limits
-type ProviderModelLimit struct {
- Context int `json:"context"`
-}
-
-// SessionCompactedProperties for session.compacted events
-type SessionCompactedProperties struct {
- SessionID string `json:"sessionID"`
-}
-
-// ParseSessionCompacted parses session.compacted properties
-func ParseSessionCompacted(data json.RawMessage) (*SessionCompactedProperties, error) {
- var props SessionCompactedProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParseTodoUpdated parses todo.updated properties
-func ParseTodoUpdated(data json.RawMessage) (*TodoUpdatedProperties, error) {
- var props TodoUpdatedProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParseSDKEvent parses an SDK event from JSON
-func ParseSDKEvent(data []byte) (*SDKEventEnvelope, error) {
- var env SDKEventEnvelope
- if err := json.Unmarshal(data, &env); err != nil {
- return nil, err
- }
- return &env, nil
-}
-
-// ParseMessageUpdated parses message.updated properties
-func ParseMessageUpdated(data json.RawMessage) (*MessageUpdatedProperties, error) {
- var props MessageUpdatedProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParseMessagePartUpdated parses message.part.updated properties
-func ParseMessagePartUpdated(data json.RawMessage) (*MessagePartUpdatedProperties, error) {
- var props MessagePartUpdatedProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParsePermissionAsked parses permission.asked properties
-func ParsePermissionAsked(data json.RawMessage) (*PermissionAskedProperties, error) {
- var props PermissionAskedProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParseSessionIdle parses session.idle properties
-func ParseSessionIdle(data json.RawMessage) (*SessionIdleProperties, error) {
- var props SessionIdleProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
-
-// ParseSessionError parses session.error properties
-func ParseSessionError(data json.RawMessage) (*SessionErrorProperties, error) {
- var props SessionErrorProperties
- if err := json.Unmarshal(data, &props); err != nil {
- return nil, err
- }
- return &props, nil
-}
diff --git a/apps/backend/pkg/opencode/types_test.go b/apps/backend/pkg/opencode/types_test.go
deleted file mode 100644
index 7caec3b89e..0000000000
--- a/apps/backend/pkg/opencode/types_test.go
+++ /dev/null
@@ -1,366 +0,0 @@
-package opencode
-
-import (
- "encoding/json"
- "testing"
-)
-
-func TestSDKEventEnvelope_ParseSDKEvent(t *testing.T) {
- tests := []struct {
- name string
- input string
- wantType string
- wantError bool
- }{
- {
- name: "message.updated event",
- input: `{"type":"message.updated","properties":{"info":{"id":"123","sessionID":"sess-1","role":"assistant"}}}`,
- wantType: SDKEventMessageUpdated,
- },
- {
- name: "message.part.updated event",
- input: `{"type":"message.part.updated","properties":{"part":{"type":"text","text":"hello"}}}`,
- wantType: SDKEventMessagePartUpdated,
- },
- {
- name: "permission.asked event",
- input: `{"type":"permission.asked","properties":{"id":"perm-1","sessionID":"sess-1","permission":"edit"}}`,
- wantType: SDKEventPermissionAsked,
- },
- {
- name: "session.idle event",
- input: `{"type":"session.idle","properties":{"sessionID":"sess-1"}}`,
- wantType: SDKEventSessionIdle,
- },
- {
- name: "session.error event",
- input: `{"type":"session.error","properties":{"sessionID":"sess-1","error":{"message":"something went wrong"}}}`,
- wantType: SDKEventSessionError,
- },
- {
- name: "invalid JSON",
- input: `{invalid`,
- wantError: true,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- event, err := ParseSDKEvent([]byte(tt.input))
- if tt.wantError {
- if err == nil {
- t.Error("expected error, got nil")
- }
- return
- }
- if err != nil {
- t.Errorf("unexpected error: %v", err)
- return
- }
- if event.Type != tt.wantType {
- t.Errorf("expected type %s, got %s", tt.wantType, event.Type)
- }
- })
- }
-}
-
-func TestParseMessageUpdated(t *testing.T) {
- input := `{"info":{"id":"msg-123","sessionID":"sess-456","role":"assistant","model":{"providerID":"anthropic","modelID":"claude-3-sonnet"},"tokens":{"input":100,"output":50,"cache":{"read":20}}}}`
-
- props, err := ParseMessageUpdated(json.RawMessage(input))
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if props.Info.ID != "msg-123" {
- t.Errorf("expected ID 'msg-123', got %s", props.Info.ID)
- }
- if props.Info.SessionID != "sess-456" {
- t.Errorf("expected sessionID 'sess-456', got %s", props.Info.SessionID)
- }
- if props.Info.Role != "assistant" {
- t.Errorf("expected role 'assistant', got %s", props.Info.Role)
- }
- if props.Info.Model == nil {
- t.Error("expected model to be set")
- } else if props.Info.Model.ProviderID != "anthropic" {
- t.Errorf("expected providerID 'anthropic', got %s", props.Info.Model.ProviderID)
- }
- if props.Info.Tokens == nil {
- t.Error("expected tokens to be set")
- } else {
- if props.Info.Tokens.Input != 100 {
- t.Errorf("expected input tokens 100, got %d", props.Info.Tokens.Input)
- }
- if props.Info.Tokens.Output != 50 {
- t.Errorf("expected output tokens 50, got %d", props.Info.Tokens.Output)
- }
- if props.Info.Tokens.Cache == nil || props.Info.Tokens.Cache.Read != 20 {
- t.Error("expected cache read 20")
- }
- }
-}
-
-func TestParseMessagePartUpdated(t *testing.T) {
- tests := []struct {
- name string
- input string
- wantType string
- wantText string
- wantID string
- }{
- {
- name: "text part with ID",
- input: `{"part":{"id":"part-123","type":"text","messageID":"msg-1","sessionID":"sess-1","text":"Hello world"},"delta":"Hello"}`,
- wantType: PartTypeText,
- wantText: "Hello world",
- wantID: "part-123",
- },
- {
- name: "text part without ID (backwards compatibility)",
- input: `{"part":{"type":"text","messageID":"msg-1","sessionID":"sess-1","text":"Hello world"},"delta":"Hello"}`,
- wantType: PartTypeText,
- wantText: "Hello world",
- wantID: "",
- },
- {
- name: "reasoning part",
- input: `{"part":{"id":"reason-1","type":"reasoning","messageID":"msg-1","sessionID":"sess-1","text":"Let me think..."}}`,
- wantType: PartTypeReasoning,
- wantText: "Let me think...",
- wantID: "reason-1",
- },
- {
- name: "tool part",
- input: `{"part":{"id":"tool-1","type":"tool","messageID":"msg-1","sessionID":"sess-1","callID":"call-1","tool":"bash","state":{"status":"running","title":"Running command"}}}`,
- wantType: PartTypeTool,
- wantID: "tool-1",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- props, err := ParseMessagePartUpdated(json.RawMessage(tt.input))
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if props.Part.Type != tt.wantType {
- t.Errorf("expected type %s, got %s", tt.wantType, props.Part.Type)
- }
- if tt.wantText != "" && props.Part.Text != tt.wantText {
- t.Errorf("expected text %q, got %q", tt.wantText, props.Part.Text)
- }
- if props.Part.ID != tt.wantID {
- t.Errorf("expected ID %q, got %q", tt.wantID, props.Part.ID)
- }
- })
- }
-}
-
-func TestParsePermissionAsked(t *testing.T) {
- input := `{"id":"perm-123","sessionID":"sess-456","permission":"bash","patterns":["npm run *"],"metadata":{"command":"npm run test"},"tool":{"callID":"call-789"}}`
-
- props, err := ParsePermissionAsked(json.RawMessage(input))
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if props.ID != "perm-123" {
- t.Errorf("expected ID 'perm-123', got %s", props.ID)
- }
- if props.SessionID != "sess-456" {
- t.Errorf("expected sessionID 'sess-456', got %s", props.SessionID)
- }
- if props.Permission != "bash" {
- t.Errorf("expected permission 'bash', got %s", props.Permission)
- }
- if len(props.Patterns) != 1 || props.Patterns[0] != "npm run *" {
- t.Errorf("expected patterns [npm run *], got %v", props.Patterns)
- }
- if props.Tool == nil || props.Tool.CallID != "call-789" {
- t.Error("expected tool with callID 'call-789'")
- }
- if cmd, ok := props.Metadata["command"].(string); !ok || cmd != "npm run test" {
- t.Errorf("expected metadata command 'npm run test', got %v", props.Metadata)
- }
-}
-
-func TestParseSessionIdle(t *testing.T) {
- input := `{"sessionID":"sess-123"}`
-
- props, err := ParseSessionIdle(json.RawMessage(input))
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if props.SessionID != "sess-123" {
- t.Errorf("expected sessionID 'sess-123', got %s", props.SessionID)
- }
-}
-
-func TestParseSessionError(t *testing.T) {
- tests := []struct {
- name string
- input string
- wantKind string
- wantMessage string
- }{
- {
- name: "error with name and data.message",
- input: `{"sessionID":"sess-1","error":{"name":"ProviderAuthError","data":{"message":"API key invalid"}}}`,
- wantKind: "ProviderAuthError",
- wantMessage: "API key invalid",
- },
- {
- name: "error with type and message",
- input: `{"sessionID":"sess-1","error":{"type":"RateLimitError","message":"Rate limit exceeded"}}`,
- wantKind: "RateLimitError",
- wantMessage: "Rate limit exceeded",
- },
- {
- name: "no error",
- input: `{"sessionID":"sess-1"}`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- props, err := ParseSessionError(json.RawMessage(tt.input))
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if tt.wantKind == "" {
- if props.Error != nil {
- t.Error("expected no error, but got one")
- }
- return
- }
-
- if props.Error == nil {
- t.Fatal("expected error, got nil")
- }
-
- if props.Error.GetKind() != tt.wantKind {
- t.Errorf("expected kind %s, got %s", tt.wantKind, props.Error.GetKind())
- }
- if props.Error.GetMessage() != tt.wantMessage {
- t.Errorf("expected message %s, got %s", tt.wantMessage, props.Error.GetMessage())
- }
- })
- }
-}
-
-func TestSDKError_GetKind(t *testing.T) {
- tests := []struct {
- name string
- err SDKError
- wantKind string
- }{
- {
- name: "name takes precedence",
- err: SDKError{Name: "AuthError", Type: "SomeType"},
- wantKind: "AuthError",
- },
- {
- name: "falls back to type",
- err: SDKError{Type: "SomeType"},
- wantKind: "SomeType",
- },
- {
- name: "returns unknown",
- err: SDKError{},
- wantKind: "unknown",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := tt.err.GetKind(); got != tt.wantKind {
- t.Errorf("expected kind %s, got %s", tt.wantKind, got)
- }
- })
- }
-}
-
-func TestSDKError_GetMessage(t *testing.T) {
- tests := []struct {
- name string
- err SDKError
- wantMessage string
- }{
- {
- name: "data.message takes precedence",
- err: SDKError{
- Message: "outer message",
- Data: &struct {
- Message string `json:"message,omitempty"`
- }{Message: "inner message"},
- },
- wantMessage: "inner message",
- },
- {
- name: "falls back to message",
- err: SDKError{Message: "outer message"},
- wantMessage: "outer message",
- },
- {
- name: "returns empty",
- err: SDKError{},
- wantMessage: "",
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := tt.err.GetMessage(); got != tt.wantMessage {
- t.Errorf("expected message %s, got %s", tt.wantMessage, got)
- }
- })
- }
-}
-
-func TestToolStateUpdate_Statuses(t *testing.T) {
- tests := []struct {
- status string
- }{
- {ToolStatusPending},
- {ToolStatusRunning},
- {ToolStatusCompleted},
- {ToolStatusError},
- }
-
- for _, tt := range tests {
- t.Run(tt.status, func(t *testing.T) {
- state := ToolStateUpdate{Status: tt.status}
- if state.Status != tt.status {
- t.Errorf("expected status %s, got %s", tt.status, state.Status)
- }
- })
- }
-}
-
-func TestExecutorEvent_JSON(t *testing.T) {
- event := ExecutorEvent{
- Type: EventTypeSessionStart,
- SessionID: "sess-123",
- }
-
- data, err := json.Marshal(event)
- if err != nil {
- t.Fatalf("failed to marshal: %v", err)
- }
-
- var parsed ExecutorEvent
- if err := json.Unmarshal(data, &parsed); err != nil {
- t.Fatalf("failed to unmarshal: %v", err)
- }
-
- if parsed.Type != event.Type {
- t.Errorf("expected type %s, got %s", event.Type, parsed.Type)
- }
- if parsed.SessionID != event.SessionID {
- t.Errorf("expected sessionID %s, got %s", event.SessionID, parsed.SessionID)
- }
-}
diff --git a/docs/agents/claude_code.md b/docs/agents/claude_code.md
deleted file mode 100644
index 6bd4523938..0000000000
--- a/docs/agents/claude_code.md
+++ /dev/null
@@ -1,587 +0,0 @@
-# Claude Code Integration
-
-Technical reference for Kandev's Claude Code CLI integration. Covers the stream-json protocol, message lifecycle, control plane, tool normalization, session resume, and permission hooks.
-
-## Protocol Overview
-
-Kandev communicates with Claude Code via the **stream-json** protocol: newline-delimited JSON over stdin/stdout. The CLI runs as a subprocess managed by agentctl.
-
-```
-┌─────────────┐ stdin (JSON lines) ┌──────────────────┐
-│ agentctl │ ──────────────────► │ Claude Code CLI │
-│ (adapter) │ ◄────────────────── │ (subprocess) │
-└─────────────┘ stdout (JSON lines) └──────────────────┘
-```
-
-**CLI invocation:**
-```
-npx -y @anthropic-ai/claude-code@
- -p # Print mode (non-interactive)
- --output-format=stream-json # Streaming JSON output
- --input-format=stream-json # Streaming JSON input
- --permission-prompt-tool=stdio # Permission prompts via stdio control messages
- --include-partial-messages # Stream in-progress assistant messages
- --replay-user-messages # Replay user messages on session resume
- --verbose # Extended logging
- --model # Model selection
- --resume # Resume existing session
-```
-
----
-
-## Architecture
-
-```
-pkg/claudecode/
-├── types.go # Protocol message types, constants, structs
-└── client.go # stdin/stdout client, read loop, control request handling
-
-internal/agentctl/server/adapter/transport/streamjson/
-├── adapter.go # Main adapter: state, dispatch, sendUpdate
-├── streamjson_init.go # Initialize, hooks, MCP config
-├── streamjson_session.go # NewSession / LoadSession
-├── streamjson_prompt.go # Prompt sending, image attachments, Cancel
-├── streamjson_messages.go # System, assistant, user, rate-limit handlers
-├── streamjson_result.go # Result handler, deduplication, completion
-├── streamjson_permissions.go # Permission requests, hook callbacks, timeout
-├── streamjson_tracing.go # OTel tracing helpers for control messages
-└── normalize.go # Tool data → NormalizedPayload conversion
-```
-
----
-
-## Message Types
-
-Every line on stdout is a JSON object with a `type` field. The client dispatches based on this type:
-
-| Type | Direction | Description |
-|------|-----------|-------------|
-| `system` | CLI → Adapter | Session initialization (session_id, status, slash commands) |
-| `assistant` | CLI → Adapter | Assistant response with content blocks (text, thinking, tool_use) |
-| `user` | CLI → Adapter | Tool results (tool_result blocks) or slash command output |
-| `result` | CLI → Adapter | Turn completion with stats (cost, tokens, duration, errors) |
-| `rate_limit` | CLI → Adapter | API rate limit notification |
-| `control_request` | CLI → Adapter | Permission request or hook callback |
-| `control_cancel_request` | CLI → Adapter | Cancels a pending permission/hook request |
-| `control_response` | Adapter → CLI | Response to a control_request |
-
----
-
-## Message Lifecycle
-
-### Client Layer (`pkg/claudecode/client.go`)
-
-The `Client` reads stdout via `bufio.Scanner` (10 MB buffer), parses each line into a `CLIMessage`, and dispatches:
-
-```
-stdout line
- │
- ├── type=control_request → RequestHandler(requestID, *ControlRequest)
- ├── type=control_cancel_request → CancelHandler(requestID)
- ├── type=control_response → matches pending request by ID, unblocks goroutine
- └── (all other types) → MessageHandler(*CLIMessage)
-```
-
-Control messages are handled immediately. All other messages are forwarded to the adapter's `handleMessage()`.
-
-### Adapter Layer (`streamjson/adapter.go`)
-
-The adapter's `handleMessage()` marshals the message for debug logging/tracing, then dispatches:
-
-```
-handleMessage(msg)
- │
- ├── system → handleSystemMessage → session_status, available_commands
- ├── assistant → handleAssistantMessage → message_chunk, reasoning, tool_call, context_window
- ├── user → handleUserMessage → tool_update (complete/error), message_chunk (slash cmds)
- ├── result → handleResultMessage → complete, error (+ auto-complete pending tools)
- └── rate_limit → handleRateLimitMessage → rate_limit
-```
-
-Every dispatched event goes through `sendUpdate()`, which:
-1. Logs the normalized event (JSONL debug file)
-2. Creates an OTel span (child of the active prompt span)
-3. Sends to the `updatesCh` channel for WebSocket delivery
-
----
-
-## Turn Anatomy
-
-A single turn (prompt → result) produces this message sequence:
-
-```
-Adapter Claude Code CLI
- │ │
- │ ── user message (prompt) ──────────► │
- │ │
- │ ◄── system (session_id, status) ──── │ (first prompt only)
- │ ◄── assistant (text blocks) ──────── │ (streaming chunks)
- │ ◄── assistant (thinking blocks) ──── │ (reasoning, if enabled)
- │ ◄── assistant (tool_use block) ───── │ (tool invocation)
- │ │
- │ ◄── control_request (can_use_tool) ─ │ (if hooks require approval)
- │ ── control_response (allow/deny) ──► │
- │ │
- │ ◄── user (tool_result block) ─────── │ (tool output)
- │ ◄── assistant (text blocks) ──────── │ (more streaming)
- │ ◄── result ───────────────────────── │ (turn complete)
- │ │
-```
-
-### Text Deduplication
-
-The `result` message may contain a `text` field that duplicates already-streamed assistant text. The adapter tracks `streamingTextSentThisTurn`:
-- Set to `true` when any `message_chunk` event is sent from assistant text blocks
-- If `true` when result arrives, `result.text` is skipped
-- Reset to `false` after each result
-
-### Message UUIDs
-
-Each message has a `uuid` field used for session truncation on resume:
-- **Assistant UUIDs** are held as `pendingAssistantUUID` until the result message commits them to `lastMessageUUID`
-- **User UUIDs** are committed immediately (safe to resume from)
-- `lastMessageUUID` is included in the `complete` event and persisted for `--resume-session-at`
-
----
-
-## Content Blocks
-
-Assistant messages contain an array of content blocks:
-
-### Text Block
-```json
-{ "type": "text", "text": "Here's the implementation..." }
-```
-Emitted as `message_chunk` events for real-time streaming.
-
-### Thinking Block
-```json
-{ "type": "thinking", "thinking": "Let me analyze the code structure..." }
-```
-Emitted as `reasoning` events. Only present when extended thinking is enabled.
-
-### Tool Use Block
-```json
-{
- "type": "tool_use",
- "id": "toolu_abc123",
- "name": "Edit",
- "input": { "file_path": "/src/main.go", "old_string": "...", "new_string": "..." }
-}
-```
-Normalized into a `NormalizedPayload` and emitted as a `tool_call` event with status `"running"`.
-
-### Tool Result Block (in user messages)
-```json
-{
- "type": "tool_result",
- "tool_use_id": "toolu_abc123",
- "content": "File edited successfully",
- "is_error": false
-}
-```
-Enriches the pending `NormalizedPayload` with output data and emits a `tool_update` event with status `"complete"` or `"error"`.
-
----
-
-## Control Plane
-
-### Initialize
-
-Sent once after the subprocess starts. Registers hooks and retrieves available slash commands.
-
-```
-Adapter → CLI:
-{
- "type": "control_request",
- "request_id": "",
- "request": {
- "subtype": "initialize",
- "hooks": {
- "PreToolUse": [{ "matcher": "^Bash$", "hookCallbackIds": ["tool_approval"] }],
- "Stop": [{ "hookCallbackIds": ["stop_git_check"] }]
- }
- }
-}
-
-CLI → Adapter:
-{
- "type": "control_response",
- "response": {
- "subtype": "success",
- "request_id": "",
- "response": {
- "commands": [
- { "name": "commit", "description": "Create a git commit" },
- { "name": "review-pr", "description": "Review a pull request" }
- ]
- }
- }
-}
-```
-
-### Permission Request (can_use_tool)
-
-When the CLI needs approval for a tool call:
-
-```
-CLI → Adapter:
-{
- "type": "control_request",
- "request_id": "req_123",
- "request": {
- "subtype": "can_use_tool",
- "tool_name": "Bash",
- "tool_use_id": "toolu_abc",
- "input": { "command": "rm -rf /tmp/test" },
- "blocked_paths": "/etc,/usr"
- }
-}
-
-Adapter → CLI:
-{
- "type": "control_response",
- "request_id": "req_123",
- "response": {
- "subtype": "success",
- "result": {
- "behavior": "allow",
- "updatedPermissions": [],
- "message": ""
- }
- }
-}
-```
-
-The `behavior` field is `"allow"` or `"deny"`. On deny, an optional `interrupt: true` stops the current operation.
-
-### Hook Callbacks
-
-Hooks are registered during initialize and fire before tool execution. The response format differs from permission responses:
-
-**PreToolUse hook response:**
-```json
-{
- "type": "control_response",
- "request_id": "req_456",
- "response": {
- "subtype": "success",
- "result": {
- "hookSpecificOutput": {
- "hookEventName": "PreToolUse",
- "permissionDecision": "allow",
- "permissionDecisionReason": "Auto-approved by SDK"
- }
- }
- }
-}
-```
-
-`permissionDecision` values:
-- `"allow"` — approve the tool call
-- `"deny"` — reject the tool call
-- `"ask"` — trigger a separate `can_use_tool` permission request
-
-**Stop hook response:**
-```json
-{
- "type": "control_response",
- "request_id": "req_789",
- "response": {
- "subtype": "success",
- "result": {
- "decision": "approve",
- "reason": ""
- }
- }
-}
-```
-
-### Cancel Request
-
-The CLI can cancel a pending permission dialog (e.g., when the tool call is superseded):
-
-```
-CLI → Adapter:
-{
- "type": "control_cancel_request",
- "request_id": "req_123"
-}
-```
-
-The adapter emits a `permission_cancelled` event so the frontend closes the dialog.
-
-### Interrupt
-
-Sent by the adapter to cancel the current operation:
-
-```
-Adapter → CLI:
-{
- "type": "control_request",
- "request_id": "",
- "request": { "subtype": "interrupt" }
-}
-```
-
----
-
-## Permission Modes
-
-The adapter supports three permission policies, configured via hooks at initialize:
-
-### Autonomous (default)
-No hooks registered. `--dangerously-skip-permissions` flag bypasses all checks. Agent runs freely.
-
-### Supervised
-Uses `--permission-mode=bypassPermissions` with hooks:
-- **PreToolUse hook**: Matches all tools except safe read-only ones (`Glob`, `Grep`, `NotebookRead`, `Read`, `Task`, `TodoWrite`). Responds with `permissionDecision: "ask"` which triggers a `can_use_tool` flow, forwarding to the frontend for user approval.
-- **Stop hook**: Checks for uncommitted changes before agent exit.
-- Non-matching tools (read-only) are implicitly auto-approved by Claude Code.
-
-### Plan
-Uses `--permission-mode=bypassPermissions` with hooks:
-- **PreToolUse hook (ExitPlanMode)**: Requires approval to exit plan mode.
-- **PreToolUse hook (everything else)**: Auto-approved.
-- **Stop hook**: Same as supervised.
-
----
-
-## Result Message
-
-The result message signals turn completion and contains aggregate statistics:
-
-```json
-{
- "type": "result",
- "subtype": "success",
- "cost_usd": 0.0234,
- "duration_ms": 15234,
- "duration_api_ms": 12100,
- "is_error": false,
- "num_turns": 3,
- "total_input_tokens": 45000,
- "total_output_tokens": 2300,
- "model_usage": {
- "claude-sonnet-4-5": { "context_window": 200000 }
- },
- "result": {
- "text": "I've implemented the changes...",
- "session_id": "sess_abc123"
- }
-}
-```
-
-On result, the adapter:
-1. Auto-completes any pending tool calls that never received a `tool_result`
-2. Updates context window size from `model_usage` if available
-3. Emits result text only if no streaming text was sent this turn
-4. Commits the pending assistant UUID as `lastMessageUUID`
-5. Emits `complete` event with cost/token/duration stats
-6. Signals completion to unblock the `Prompt()` goroutine
-7. Emits `error` event if `is_error: true`
-
----
-
-## Session Resume
-
-### Resume by Session ID
-
-```
---resume
-```
-
-Resumes the conversation from the last message. The session ID is stored in the `executors_running` table as the resume token.
-
-### Resume at Message UUID
-
-```
---resume-session-at
-```
-
-Truncates the conversation to the specified message UUID and resumes from there. Used for retry — when a turn fails, resume from the last known-good message instead of replaying the failed context.
-
-The `lastMessageUUID` is:
-- Tracked from message `uuid` fields during the conversation
-- Committed on result messages (assistant UUIDs are pending until result confirms success)
-- Included in the `complete` event's `data.last_message_uuid` field
-- Persisted in the `executors_running.last_message_uuid` column
-
----
-
-## Tool Normalization
-
-The normalizer converts Claude Code tool calls into protocol-agnostic `NormalizedPayload` structs. This allows the frontend to render tools uniformly regardless of which agent produced them.
-
-### Tool → Kind Mapping
-
-| Claude Code Tool | NormalizedPayload Kind | Frontend Renderer |
-|-----------------|----------------------|-------------------|
-| `Edit`, `Write`, `NotebookEdit` | `modify_file` | `tool_edit` |
-| `Read` | `read_file` | `tool_read` |
-| `Glob`, `Grep` | `code_search` | `tool_search` |
-| `Bash` | `shell_exec` | `tool_execute` |
-| `WebFetch`, `WebSearch` | `http_request` | `tool_call` |
-| `Task` | `subagent_task` | `tool_call` |
-| `TaskCreate` | `create_task` | `tool_call` |
-| `TaskUpdate`, `TaskList`, `TodoWrite` | `manage_todos` | `todo` |
-| (unknown) | `generic` | `tool_call` |
-
-### Normalization Flow
-
-```
-tool_use block (name, id, input)
- │
- ├── NormalizeToolCall(name, input) → NormalizedPayload
- │ stored in pendingToolCalls[id]
- │
- ├── emit tool_call event (status: "running", payload attached)
- │
- ... (tool executes) ...
- │
- ├── tool_result block (tool_use_id, content, is_error)
- │
- ├── NormalizeToolResult(payload, content) → enriches payload with output
- │
- └── emit tool_update event (status: "complete" or "error", payload attached)
-```
-
-### NormalizedPayload Structure
-
-A discriminated union — exactly one kind-specific field is populated:
-
-```
-NormalizedPayload
- ├── kind: ToolKind (read_file, modify_file, shell_exec, ...)
- ├── read_file: { file_path, offset, limit, output: { content, line_count, truncated } }
- ├── modify_file: { file_path, mutations: [{ type, content, old_content, new_content, diff }] }
- ├── shell_exec: { command, work_dir, description, timeout, background, output: { exit_code, stdout, stderr } }
- ├── code_search: { query, pattern, path, glob, output: { files, file_count, truncated } }
- ├── http_request: { url, method, response, is_error }
- ├── subagent_task: { description, prompt, subagent_type }
- ├── create_task: { title, description }
- ├── manage_todos: { operation, items: [{ id, description, status }] }
- ├── generic: { name, input, output }
- └── misc: { label, details }
-```
-
----
-
-## Agent Events
-
-Events emitted through the `updatesCh` channel to the frontend via WebSocket:
-
-| Event Type | When | Key Fields |
-|-----------|------|------------|
-| `session_status` | First system message | `session_id`, `data.session_status` ("new"/"resumed") |
-| `available_commands` | After initialize or system message | `available_commands[]` (name, description) |
-| `message_chunk` | Assistant text or slash command output | `text` |
-| `reasoning` | Thinking/chain-of-thought | `reasoning_text` |
-| `tool_call` | Tool invocation starts | `tool_call_id`, `tool_name`, `tool_title`, `tool_status: "running"`, `normalized` |
-| `tool_update` | Tool result received | `tool_call_id`, `tool_status: "complete"/"error"`, `normalized` |
-| `context_window` | Token usage update | `context_window_size`, `context_window_used`, `context_window_remaining`, `context_efficiency` |
-| `complete` | Turn finished | `data` (cost_usd, duration_ms, num_turns, input/output_tokens, last_message_uuid) |
-| `error` | Turn failed | `error` message |
-| `rate_limit` | API rate limited | `rate_limit_message` |
-| `permission_cancelled` | Permission dialog cancelled | `pending_id` |
-
-### Subagent Nesting
-
-When Claude Code uses the `Task` tool, it spawns subagents. Messages from subagents include `parent_tool_use_id`, which maps to the parent `tool_call_id`. The frontend uses this for visual nesting.
-
----
-
-## Context Window Tracking
-
-Context usage is tracked from two sources:
-
-1. **Assistant messages** — `usage` field provides per-message token counts:
- ```
- context_used = input_tokens + output_tokens + cache_creation_input_tokens + cache_read_input_tokens
- ```
-
-2. **Result messages** — `model_usage` map provides the actual context window size per model:
- ```json
- { "claude-sonnet-4-5": { "context_window": 200000 } }
- ```
-
-The adapter tracks `mainModelName` (first model seen, excluding subagent models) and updates `mainModelContextWindow` from result stats. The default fallback is 200,000 tokens.
-
----
-
-## MCP Server Configuration
-
-MCP servers are passed to Claude Code via the `--mcp-config` flag:
-
-```
---mcp-config '{"mcpServers":{"my-server":{"command":"node","args":["server.js"]}}}'
-```
-
-Supported transports:
-- **stdio**: `{ "command": "...", "args": [...] }`
-- **SSE/HTTP**: `{ "url": "...", "type": "sse" }`
-
-Configuration is built from `cfg.McpServers` in `PrepareCommandArgs()`.
-
----
-
-## Image Attachments
-
-Since stream-json doesn't support multimodal content blocks in prompts, image attachments are handled by:
-
-1. Saving base64-decoded images to `.kandev/temp/images/` in the workspace
-2. Prepending file references to the prompt text
-3. Claude Code reads the images via its `Read` tool
-
-Supported formats: PNG, JPEG, GIF, WebP.
-
----
-
-## Debug & Tracing
-
-Enabled via `KANDEV_DEBUG_AGENT_MESSAGES=true`.
-
-### Debug Logging
-Writes JSONL files in the working directory:
-- `raw-streamjson-.jsonl` — raw protocol messages as received
-- `normalized-streamjson-.jsonl` — normalized AgentEvents
-
-### OTel Tracing
-Requires `OTEL_EXPORTER_OTLP_ENDPOINT` in addition to the debug flag.
-
-**Span hierarchy:**
-```
-streamjson.prompt (parent span, covers entire turn)
- ├── streamjson.system (session init)
- ├── streamjson.message_chunk (streaming text)
- ├── streamjson.reasoning (thinking)
- ├── streamjson.tool_call (tool invocation)
- ├── streamjson.tool_update (tool result)
- ├── streamjson.context_window (token usage)
- ├── streamjson.control.control_request.can_use_tool (incoming permission request)
- ├── streamjson.control.permission_response (outgoing permission response)
- ├── streamjson.control.hook_response.pre_tool_use (outgoing hook response)
- └── streamjson.complete (turn completion)
-```
-
-Each span carries `raw` and `normalized` events for side-by-side comparison in Jaeger/Tempo.
-
----
-
-## Key Source Files
-
-| File | Package | Purpose |
-|------|---------|---------|
-| `pkg/claudecode/types.go` | `claudecode` | Protocol message types and constants |
-| `pkg/claudecode/client.go` | `claudecode` | stdin/stdout client, read loop, control requests |
-| `streamjson/adapter.go` | `streamjson` | Main adapter state, message dispatch, sendUpdate |
-| `streamjson/streamjson_init.go` | `streamjson` | Initialize, hook building, MCP config |
-| `streamjson/streamjson_session.go` | `streamjson` | Session create/resume |
-| `streamjson/streamjson_prompt.go` | `streamjson` | Prompt send, wait, cancel, image attachments |
-| `streamjson/streamjson_messages.go` | `streamjson` | System, assistant, user, rate-limit handlers |
-| `streamjson/streamjson_result.go` | `streamjson` | Result processing, text dedup, completion signaling |
-| `streamjson/streamjson_permissions.go` | `streamjson` | Permissions, hooks, timeout, cancel |
-| `streamjson/normalize.go` | `streamjson` | Tool call/result → NormalizedPayload |
-| `streams/tool_payload.go` | `streams` | NormalizedPayload discriminated union |
-| `streams/agent.go` | `streams` | AgentEvent types and structure |
-| `agents/claude_code.go` | `agents` | Agent definition, CLI flags, models |