159f98efe6
* feat(web): add file browser with syntax-highlighted viewer - Add file browser component in right panel to browse workspace files - Open files in left panel tabs alongside Notes/Changes/Chat - Color-coded dots for file types (TS, JS, Go, Python, etc.) - Visual separator between main tabs and file tabs - Folders sorted to top in file tree view - LRU eviction for max 4 open file tabs - Backend handlers for workspace file tree and content via WebSocket * fix(web): refresh file tree on filesystem changes via fsnotify - Subscribe to file change notifications from agentctl's fsnotify watcher - Backend lifecycle manager now connects to file changes stream - Publishes FileChangeNotified events to event bus - WebSocket broadcasts workspace.file.changes to task subscribers - Frontend file browser refreshes tree when changes detected * perf(agentctl): use fsnotify instead of polling for git status - Replace 2-second polling with fsnotify-triggered updates - Add debouncing (300ms) to batch rapid file changes - Git status updates now triggered by actual filesystem changes - More efficient and responsive than periodic polling * refactor(agentctl): consolidate fs events into single debounced trigger - Single fsChangeTrigger channel for all filesystem events - After 300ms debounce: update git status, files, and notify subscribers - Removed per-file notifications in favor of single 'refresh' event - Simpler and more efficient than separate triggers * refactor(agentctl): simplify file API - use HTTP for tree/content - Remove unused filesConn, fileTreeConn, fileContentConn from Client struct - Convert RequestFileTree and RequestFileContent from WebSocket to HTTP GET - Remove StreamFiles and CloseFilesStream (redundant with file changes stream) - Keep only fileChangesConn for the debounced refresh notification HTTP is simpler than WebSocket for request/response patterns. * feat(web): switch to CodeMirror for file viewer - Replace react-syntax-highlighter with @uiw/react-codemirror - Add language extensions for JS/TS, Python, Go, Rust, Java, C++, CSS, HTML, JSON, Markdown, YAML - Use VS Code dark theme for consistent look - Enable code folding and read-only mode - Better performance and features than syntax highlighter * refactor: consolidate duplicated types and extract shared constants - Re-export file types from process package in agentctl/client.go instead of duplicating - Move OpenFileTab type to lib/types/backend.ts (shared by file-browser and page-client) - Extract FILE_EXTENSION_COLORS constant for file type color indicators - Remove console.log statement and unused imports in file-browser.tsx - Add 'refresh' operation to FileChangeNotificationPayload type * refactor(agentctl): move Close() method from acp.go to client.go Close() is a general client cleanup method that closes all streams (ACP, permissions, git status, file changes). It belongs in client.go since acp.go should only contain ACP-specific communication logic. * fix(web): remove unused cn import in file-browser * refactor(agentctl): consolidate duplicated types into process/types.go - Create process/types.go with all workspace-related types - Remove duplicate GitStatusUpdate, FileInfo from workspace_tracker.go - Remove duplicate GitStatusUpdate, FileInfo from api/workspace.go - Re-export all types from agent/agentctl/client.go for convenience Types are now defined once and imported everywhere. * chore: remove package-lock.json, add to .gitignore Project uses pnpm (pnpm-lock.yaml), not npm. * fix(orchestrator): probe agent before returning stale execution state When checking task.execution, the backend now probes the actual agent: - For tracked instances: health check via agentctl - For Docker: verify container is running If the agent is not running but DB says 'running', the session is marked as stopped and false is returned. This fixes the UI showing agents as running after backend restart when they're actually dead. Changes: - Add IsAgentRunningForTask to AgentManagerClient interface - Add IsContainerRunning to docker client - Update GetExecution to verify agent is actually running - Clean up stale sessions in database when agent not found * fix(orchestrator): use agentctl status to verify agent is running Simplified approach - probe agentctl's /api/v1/status endpoint to check if agent process is running. Same check for both Docker and standalone. - Add IsAgentRunning() helper to StatusResponse - Simplify IsAgentRunningForTask to just use agentctl.GetStatus() * fix(orchestrator): also verify agent running for in-memory executions The previous fix only checked agent status when loading from DB. But if an execution is cached in memory and the agent process stops (while agentctl stays running), the stale state was still returned. Now both paths verify the agent is actually running by probing agentctl. If agent stopped, clean up in-memory state and update DB session. * chore(web): remove unused react-syntax-highlighter Switched to CodeMirror for code viewing, no longer needed. * fix(tests): add IsAgentRunningForTask to mock agent managers Add the new interface method to test mocks: - mockAgentManager in scheduler_test.go - SimulatedAgentManagerClient in orchestrator_test.go --------- Co-authored-by: Kandev Agent <kandev@example.com>
366 lines
9.2 KiB
Go
366 lines
9.2 KiB
Go
// Package agentctl provides a client for communicating with agentctl running inside containers
|
|
package agentctl
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"github.com/kandev/kandev/internal/agentctl/process"
|
|
"github.com/kandev/kandev/internal/common/logger"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// Client communicates with agentctl via HTTP
|
|
type Client struct {
|
|
baseURL string
|
|
httpClient *http.Client
|
|
logger *logger.Logger
|
|
|
|
// WebSocket connections for streaming
|
|
acpConn *websocket.Conn
|
|
permissionConn *websocket.Conn
|
|
gitStatusConn *websocket.Conn
|
|
fileChangesConn *websocket.Conn
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
// StatusResponse from agentctl
|
|
type StatusResponse struct {
|
|
AgentStatus string `json:"agent_status"`
|
|
ProcessInfo map[string]interface{} `json:"process_info"`
|
|
}
|
|
|
|
// IsAgentRunning returns true if the agent process is running
|
|
func (s *StatusResponse) IsAgentRunning() bool {
|
|
return s.AgentStatus == "running"
|
|
}
|
|
|
|
// NewClient creates a new agentctl client
|
|
func NewClient(host string, port int, log *logger.Logger) *Client {
|
|
return &Client{
|
|
baseURL: fmt.Sprintf("http://%s:%d", host, port),
|
|
httpClient: &http.Client{
|
|
Timeout: 30 * time.Second,
|
|
},
|
|
logger: log.WithFields(zap.String("component", "agentctl-client")),
|
|
}
|
|
}
|
|
|
|
// Health checks if agentctl is healthy
|
|
func (c *Client) Health(ctx context.Context) error {
|
|
req, err := http.NewRequestWithContext(ctx, "GET", c.baseURL+"/health", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("health check failed: %d", resp.StatusCode)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetStatus returns the agent status
|
|
func (c *Client) GetStatus(ctx context.Context) (*StatusResponse, error) {
|
|
req, err := http.NewRequestWithContext(ctx, "GET", c.baseURL+"/api/v1/status", nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var status StatusResponse
|
|
if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
|
|
return nil, err
|
|
}
|
|
return &status, nil
|
|
}
|
|
|
|
// Start starts the agent process
|
|
func (c *Client) Start(ctx context.Context) error {
|
|
req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/start", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var result struct {
|
|
Success bool `json:"success"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return err
|
|
}
|
|
if !result.Success {
|
|
return fmt.Errorf("start failed: %s", result.Error)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Stop stops the agent process
|
|
func (c *Client) Stop(ctx context.Context) error {
|
|
req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/stop", nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var result struct {
|
|
Success bool `json:"success"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return err
|
|
}
|
|
if !result.Success {
|
|
return fmt.Errorf("stop failed: %s", result.Error)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// WaitForReady waits until agentctl is ready to accept requests
|
|
func (c *Client) WaitForReady(ctx context.Context, timeout time.Duration) error {
|
|
deadline := time.Now().Add(timeout)
|
|
ticker := time.NewTicker(500 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case <-ticker.C:
|
|
if time.Now().After(deadline) {
|
|
return fmt.Errorf("timeout waiting for agentctl to be ready")
|
|
}
|
|
|
|
if err := c.Health(ctx); err == nil {
|
|
c.logger.Info("agentctl is ready")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// BaseURL returns the base URL of the agentctl client
|
|
func (c *Client) BaseURL() string {
|
|
return c.baseURL
|
|
}
|
|
|
|
// Re-export types from process package for convenience
|
|
type (
|
|
GitStatusUpdate = process.GitStatusUpdate
|
|
FileInfo = process.FileInfo
|
|
FileListUpdate = process.FileListUpdate
|
|
FileEntry = process.FileEntry
|
|
FileTreeNode = process.FileTreeNode
|
|
FileTreeRequest = process.FileTreeRequest
|
|
FileTreeResponse = process.FileTreeResponse
|
|
FileContentRequest = process.FileContentRequest
|
|
FileContentResponse = process.FileContentResponse
|
|
FileChangeNotification = process.FileChangeNotification
|
|
)
|
|
|
|
// StreamGitStatus opens a WebSocket connection for streaming git status updates
|
|
func (c *Client) StreamGitStatus(ctx context.Context, handler func(*GitStatusUpdate)) error {
|
|
wsURL := "ws" + c.baseURL[4:] + "/api/v1/workspace/git-status/stream"
|
|
|
|
conn, _, err := websocket.DefaultDialer.DialContext(ctx, wsURL, nil)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to connect to git status stream: %w", err)
|
|
}
|
|
|
|
c.mu.Lock()
|
|
c.gitStatusConn = conn
|
|
c.mu.Unlock()
|
|
|
|
c.logger.Info("connected to git status stream", zap.String("url", wsURL))
|
|
|
|
// Read messages in a goroutine
|
|
go func() {
|
|
defer func() {
|
|
c.mu.Lock()
|
|
c.gitStatusConn = nil
|
|
c.mu.Unlock()
|
|
conn.Close()
|
|
}()
|
|
|
|
for {
|
|
_, message, err := conn.ReadMessage()
|
|
if err != nil {
|
|
if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
|
|
c.logger.Info("git status stream closed normally")
|
|
} else {
|
|
c.logger.Debug("git status stream error", zap.Error(err))
|
|
}
|
|
return
|
|
}
|
|
|
|
var update GitStatusUpdate
|
|
if err := json.Unmarshal(message, &update); err != nil {
|
|
c.logger.Warn("failed to parse git status update", zap.Error(err))
|
|
continue
|
|
}
|
|
|
|
handler(&update)
|
|
}
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
// CloseGitStatusStream closes the git status stream connection
|
|
func (c *Client) CloseGitStatusStream() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
if c.gitStatusConn != nil {
|
|
c.gitStatusConn.Close()
|
|
c.gitStatusConn = nil
|
|
}
|
|
}
|
|
|
|
// StreamFileChanges opens a WebSocket connection for streaming file change notifications
|
|
func (c *Client) StreamFileChanges(ctx context.Context, handler func(*FileChangeNotification)) error {
|
|
wsURL := "ws" + c.baseURL[4:] + "/api/v1/workspace/file-changes/stream"
|
|
|
|
conn, _, err := websocket.DefaultDialer.DialContext(ctx, wsURL, nil)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to connect to file changes stream: %w", err)
|
|
}
|
|
|
|
c.mu.Lock()
|
|
c.fileChangesConn = conn
|
|
c.mu.Unlock()
|
|
|
|
c.logger.Info("connected to file changes stream", zap.String("url", wsURL))
|
|
|
|
// Read messages in a goroutine
|
|
go func() {
|
|
defer func() {
|
|
c.mu.Lock()
|
|
c.fileChangesConn = nil
|
|
c.mu.Unlock()
|
|
conn.Close()
|
|
}()
|
|
|
|
for {
|
|
_, message, err := conn.ReadMessage()
|
|
if err != nil {
|
|
if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
|
|
c.logger.Info("file changes stream closed normally")
|
|
} else {
|
|
c.logger.Debug("file changes stream error", zap.Error(err))
|
|
}
|
|
return
|
|
}
|
|
|
|
var notification FileChangeNotification
|
|
if err := json.Unmarshal(message, ¬ification); err != nil {
|
|
c.logger.Warn("failed to parse file change notification", zap.Error(err))
|
|
continue
|
|
}
|
|
|
|
handler(¬ification)
|
|
}
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
// RequestFileTree requests a file tree via HTTP GET
|
|
func (c *Client) RequestFileTree(ctx context.Context, path string, depth int) (*FileTreeResponse, error) {
|
|
url := fmt.Sprintf("%s/api/v1/workspace/tree?path=%s&depth=%d", c.baseURL, path, depth)
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to request file tree: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var response FileTreeResponse
|
|
if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
|
|
if response.Error != "" {
|
|
return nil, fmt.Errorf("file tree error: %s", response.Error)
|
|
}
|
|
|
|
return &response, nil
|
|
}
|
|
|
|
// RequestFileContent requests file content via HTTP GET
|
|
func (c *Client) RequestFileContent(ctx context.Context, path string) (*FileContentResponse, error) {
|
|
url := fmt.Sprintf("%s/api/v1/workspace/file/content?path=%s", c.baseURL, path)
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to request file content: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var response FileContentResponse
|
|
if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response: %w", err)
|
|
}
|
|
|
|
if response.Error != "" {
|
|
return nil, fmt.Errorf("file content error: %s", response.Error)
|
|
}
|
|
|
|
return &response, nil
|
|
}
|
|
|
|
// CloseFileChangesStream closes the file changes stream connection
|
|
func (c *Client) CloseFileChangesStream() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
if c.fileChangesConn != nil {
|
|
c.fileChangesConn.Close()
|
|
c.fileChangesConn = nil
|
|
}
|
|
}
|
|
|
|
// Close closes all connections (ACP, permissions, git status, file changes)
|
|
func (c *Client) Close() {
|
|
c.CloseACPStream()
|
|
c.ClosePermissionStream()
|
|
c.CloseGitStatusStream()
|
|
c.CloseFileChangesStream()
|
|
}
|