2e108b040f
* feat: session resumption with ACP session ID support - Add useSessionResumption hook for automatic session recovery on page reload - Fix ACPSessionID not being set on AgentInstance in Launch() and createInstance() - Add task.session.status and task.session.resume WebSocket actions - Fix shell terminal retry logic for resumed sessions - Fix taskSessionState reading from Zustand store instead of local state - Remove dead code: unused stream handling functions in lifecycle/manager.go - Fix test mock interfaces (CleanupStaleInstanceByTaskID, NewManager signature) - Add enhanced logging for session resumption debugging - Simplify page-client.tsx state merging logic * refactor: remove unused AgentController (dead code) - Delete agent_controller.go - entirely unused duplicate of Manager methods - Remove agentController field from Manager struct - Remove AgentController initialization in NewManager The AgentController duplicated StartAgentProcess, initializeACPSession, and PromptAgent from Manager but was never called. All agent control operations go through Manager's own methods. * refactor: remove unused MemoryRepository (dead code) - Delete memory.go - entire MemoryRepository implementation unused (replaced by SQLite repository) - Delete memory_test.go - tests for removed MemoryRepository Found via 'deadcode' tool analysis. * refactor: consolidate agentctl packages into server/client structure Reorganize the confusing dual agentctl packages: - internal/agentctl/* → internal/agentctl/server/ - internal/agent/agentctl/* → internal/agentctl/client/ Structure is now: internal/agentctl/ ├── client/ - HTTP client for talking to agentctl servers │ ├── client.go │ ├── standalone.go │ ├── acp.go │ └── launcher/ ├── server/ - agentctl server implementation (runs in containers) │ ├── api/ │ ├── adapter/ │ ├── acp/ │ ├── config/ │ ├── instance/ │ ├── process/ │ └── shell/ └── types/ - Shared types used by both client and server Also consolidated shared types (GitStatusUpdate, FileInfo, etc.) from process/types.go into the shared types/ package. * refactor: rename AgentInstance to AgentExecution for clarity Rename AgentInstance -> AgentExecution across the entire codebase to better reflect what it represents: an agent actively working on a task, not just a generic 'instance'. Changes: - AgentInstance struct -> AgentExecution - InstanceStore -> ExecutionStore (new file: execution_store.go) - RecoveredInstance -> RecoveredExecution - All method names: GetInstance* -> GetExecution*, ListInstances -> ListExecutions, etc. - All parameters: instanceID -> executionID - All local variables: instance -> execution - DTOs and JSON tags: agent_instance_id -> agent_execution_id - Database columns: agent_instance_id -> agent_execution_id Also consolidates duplicate prompt logic: - Merge sendInitialPrompt and SendPrompt into single SendPrompt method - Add validateStatus parameter to differentiate initial vs follow-up prompts Also extracts ACP session management to session.go: - Move initializeACPSession logic to SessionManager.InitializeAndPrompt - Move PromptAgent logic to SessionManager.SendPrompt - Manager now delegates to SessionManager for all prompt operations Also removes duplicate event publishing: - Remove 9 duplicate m.publish*() methods from manager.go - Use existing EventPublisher methods via m.eventPublisher.Publish*() Also extracts types to dedicated file: - Move AgentExecution, LaunchRequest, PromptResult, etc. to types.go Net reduction: ~600 lines removed from manager.go through deduplication and better separation of concerns. * fix(backend): Docker runtime now creates instance via ControlServer The Docker runtime was incorrectly creating an agentctl.Client pointing directly to port 9999 (the ControlServer port), then trying to call instance-specific APIs like /api/v1/agent/configure which only exist on per-instance servers. Fixed by making Docker runtime follow the same flow as standalone mode: - LaunchContainer now uses StandaloneCtl to create an instance via the control API, then creates Client pointing to the instance port - RecoverInstances queries the ControlServer to get the instance port - Added waitForHealth helper to wait for agentctl to be ready Also improved HTTP error handling in agentctl client: - All client methods now check HTTP status codes before JSON decoding - Better error messages include status code and response body * fix: restore session resumption imports and variables * fix: add sessionId prop back to TaskLayout
194 lines
5.1 KiB
Go
194 lines
5.1 KiB
Go
// Package lifecycle manages agent execution lifecycles including tracking,
|
|
// state transitions, and cleanup.
|
|
package lifecycle
|
|
|
|
import (
|
|
"sync"
|
|
|
|
v1 "github.com/kandev/kandev/pkg/api/v1"
|
|
)
|
|
|
|
// ExecutionStore provides thread-safe storage and retrieval of agent executions.
|
|
// It maintains three indexes for efficient lookup by execution ID, task ID, and container ID.
|
|
type ExecutionStore struct {
|
|
executions map[string]*AgentExecution
|
|
byTask map[string]string // taskID -> executionID
|
|
byContainer map[string]string // containerID -> executionID
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
// NewExecutionStore creates a new ExecutionStore with initialized maps.
|
|
func NewExecutionStore() *ExecutionStore {
|
|
return &ExecutionStore{
|
|
executions: make(map[string]*AgentExecution),
|
|
byTask: make(map[string]string),
|
|
byContainer: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
// Add adds an agent execution to all tracking maps.
|
|
// The execution must have a valid ID. TaskID and ContainerID are optional
|
|
// but will be indexed if present.
|
|
func (s *ExecutionStore) Add(execution *AgentExecution) {
|
|
if execution == nil || execution.ID == "" {
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
s.executions[execution.ID] = execution
|
|
|
|
if execution.TaskID != "" {
|
|
s.byTask[execution.TaskID] = execution.ID
|
|
}
|
|
|
|
if execution.ContainerID != "" {
|
|
s.byContainer[execution.ContainerID] = execution.ID
|
|
}
|
|
}
|
|
|
|
// Remove removes an agent execution from all tracking maps.
|
|
func (s *ExecutionStore) Remove(executionID string) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
execution, exists := s.executions[executionID]
|
|
if !exists {
|
|
return
|
|
}
|
|
|
|
// Remove from secondary indexes
|
|
if execution.TaskID != "" {
|
|
delete(s.byTask, execution.TaskID)
|
|
}
|
|
if execution.ContainerID != "" {
|
|
delete(s.byContainer, execution.ContainerID)
|
|
}
|
|
|
|
// Remove from primary map
|
|
delete(s.executions, executionID)
|
|
}
|
|
|
|
// Get returns an agent execution by its ID.
|
|
func (s *ExecutionStore) Get(executionID string) (*AgentExecution, bool) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
execution, exists := s.executions[executionID]
|
|
return execution, exists
|
|
}
|
|
|
|
// GetByTaskID returns the agent execution associated with a task ID.
|
|
func (s *ExecutionStore) GetByTaskID(taskID string) (*AgentExecution, bool) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
executionID, exists := s.byTask[taskID]
|
|
if !exists {
|
|
return nil, false
|
|
}
|
|
|
|
execution, exists := s.executions[executionID]
|
|
return execution, exists
|
|
}
|
|
|
|
// GetByContainerID returns the agent execution associated with a container ID.
|
|
func (s *ExecutionStore) GetByContainerID(containerID string) (*AgentExecution, bool) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
executionID, exists := s.byContainer[containerID]
|
|
if !exists {
|
|
return nil, false
|
|
}
|
|
|
|
execution, exists := s.executions[executionID]
|
|
return execution, exists
|
|
}
|
|
|
|
// List returns all tracked agent executions.
|
|
func (s *ExecutionStore) List() []*AgentExecution {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
result := make([]*AgentExecution, 0, len(s.executions))
|
|
for _, execution := range s.executions {
|
|
result = append(result, execution)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// UpdateStatus updates the status of an agent execution.
|
|
func (s *ExecutionStore) UpdateStatus(executionID string, status v1.AgentStatus) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if execution, exists := s.executions[executionID]; exists {
|
|
execution.Status = status
|
|
}
|
|
}
|
|
|
|
// UpdateProgress updates the progress of an agent execution.
|
|
func (s *ExecutionStore) UpdateProgress(executionID string, progress int) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if execution, exists := s.executions[executionID]; exists {
|
|
execution.Progress = progress
|
|
}
|
|
}
|
|
|
|
// UpdateError updates the error message of an agent execution and sets its status to failed.
|
|
func (s *ExecutionStore) UpdateError(executionID string, errorMsg string) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if execution, exists := s.executions[executionID]; exists {
|
|
execution.ErrorMessage = errorMsg
|
|
execution.Status = v1.AgentStatusFailed
|
|
}
|
|
}
|
|
|
|
// UpdateMetadata updates the metadata of an agent execution using the provided function.
|
|
func (s *ExecutionStore) UpdateMetadata(executionID string, updateFn func(metadata map[string]interface{}) map[string]interface{}) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if execution, exists := s.executions[executionID]; exists {
|
|
if execution.Metadata == nil {
|
|
execution.Metadata = make(map[string]interface{})
|
|
}
|
|
execution.Metadata = updateFn(execution.Metadata)
|
|
}
|
|
}
|
|
|
|
// WithLock executes a function with the store lock held, providing access to the execution.
|
|
// Returns false if the execution doesn't exist.
|
|
func (s *ExecutionStore) WithLock(executionID string, fn func(execution *AgentExecution)) bool {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
execution, exists := s.executions[executionID]
|
|
if !exists {
|
|
return false
|
|
}
|
|
fn(execution)
|
|
return true
|
|
}
|
|
|
|
// WithRLock executes a function with the store read lock held, providing access to the execution.
|
|
// Returns false if the execution doesn't exist.
|
|
func (s *ExecutionStore) WithRLock(executionID string, fn func(execution *AgentExecution)) bool {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
execution, exists := s.executions[executionID]
|
|
if !exists {
|
|
return false
|
|
}
|
|
fn(execution)
|
|
return true
|
|
}
|
|
|