Files
kandev/apps/backend/internal/agent/lifecycle/runtime_docker.go
T
João Salavisa 2e108b040f refactor: session resumption cleanup and AgentInstance → AgentExecution rename (#23)
* 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
2026-01-16 22:14:19 +00:00

187 lines
5.2 KiB
Go

package lifecycle
import (
"context"
"fmt"
"time"
"go.uber.org/zap"
agentctl "github.com/kandev/kandev/internal/agentctl/client"
"github.com/kandev/kandev/internal/agent/docker"
"github.com/kandev/kandev/internal/common/logger"
)
// DockerRuntime implements Runtime for Docker-based agent execution.
type DockerRuntime struct {
containerMgr *ContainerManager
docker *docker.Client
logger *logger.Logger
}
// NewDockerRuntime creates a new Docker runtime.
func NewDockerRuntime(dockerClient *docker.Client, log *logger.Logger) *DockerRuntime {
return &DockerRuntime{
containerMgr: NewContainerManager(dockerClient, "", log),
docker: dockerClient,
logger: log.WithFields(zap.String("runtime", "docker")),
}
}
func (r *DockerRuntime) Name() string {
return "docker"
}
func (r *DockerRuntime) HealthCheck(ctx context.Context) error {
// Check Docker is reachable by listing containers
_, err := r.docker.ListContainers(ctx, map[string]string{})
if err != nil {
return fmt.Errorf("docker not reachable: %w", err)
}
return nil
}
func (r *DockerRuntime) CreateInstance(ctx context.Context, req *RuntimeCreateRequest) (*RuntimeInstance, error) {
// Convert RuntimeCreateRequest to ContainerConfig
containerCfg := ContainerConfig{
AgentConfig: req.AgentConfig,
WorkspacePath: req.WorkspacePath,
TaskID: req.TaskID,
InstanceID: req.InstanceID,
MainRepoGitDir: req.MainRepoGitDir,
Credentials: req.Env, // Env contains credentials from the caller
}
// Use ContainerManager to launch container
containerID, client, err := r.containerMgr.LaunchContainer(ctx, containerCfg)
if err != nil {
return nil, fmt.Errorf("failed to launch container: %w", err)
}
// Get container IP for logging
containerIP, _ := r.docker.GetContainerIP(ctx, containerID)
// Build metadata
metadata := make(map[string]interface{})
if req.WorktreeID != "" {
metadata["worktree_id"] = req.WorktreeID
metadata["worktree_path"] = req.WorkspacePath
metadata["worktree_branch"] = req.WorktreeBranch
}
r.logger.Info("docker instance created",
zap.String("instance_id", req.InstanceID),
zap.String("container_id", containerID),
zap.String("container_ip", containerIP))
return &RuntimeInstance{
InstanceID: req.InstanceID,
TaskID: req.TaskID,
Client: client,
ContainerID: containerID,
ContainerIP: containerIP,
WorkspacePath: "/workspace", // Docker mounts workspace to /workspace
Metadata: metadata,
}, nil
}
func (r *DockerRuntime) StopInstance(ctx context.Context, instance *RuntimeInstance, force bool) error {
if instance.ContainerID == "" {
return nil // No container to stop
}
var err error
if force {
err = r.docker.KillContainer(ctx, instance.ContainerID, "SIGKILL")
} else {
err = r.docker.StopContainer(ctx, instance.ContainerID, 30*time.Second)
}
if err != nil {
return fmt.Errorf("failed to stop container: %w", err)
}
return nil
}
func (r *DockerRuntime) RecoverInstances(ctx context.Context) ([]*RuntimeInstance, error) {
// Find containers with kandev.managed label
containers, err := r.docker.ListContainers(ctx, map[string]string{
"kandev.managed": "true",
})
if err != nil {
return nil, fmt.Errorf("failed to list containers: %w", err)
}
var recovered []*RuntimeInstance
for _, ctr := range containers {
// Only recover running containers
if ctr.State != "running" {
r.logger.Debug("skipping non-running container",
zap.String("container_id", ctr.ID),
zap.String("state", ctr.State))
continue
}
// Get container labels to extract instance info
labels, err := r.docker.GetContainerLabels(ctx, ctr.ID)
if err != nil {
r.logger.Warn("failed to get container labels",
zap.String("container_id", ctr.ID),
zap.Error(err))
continue
}
instanceID := labels["kandev.instance_id"]
taskID := labels["kandev.task_id"]
agentProfileID := labels["kandev.agent_profile_id"]
if instanceID == "" || taskID == "" {
r.logger.Warn("container missing required labels",
zap.String("container_id", ctr.ID))
continue
}
// Get container IP
containerIP, err := r.docker.GetContainerIP(ctx, ctr.ID)
if err != nil {
r.logger.Warn("failed to get container IP",
zap.String("container_id", ctr.ID),
zap.Error(err))
containerIP = "127.0.0.1"
}
// Query the ControlServer to get the instance port
ctl := agentctl.NewStandaloneCtl(containerIP, AgentCtlPort, r.logger)
instanceInfo, err := ctl.GetInstance(ctx, instanceID)
if err != nil {
r.logger.Warn("failed to get instance info from container",
zap.String("container_id", ctr.ID),
zap.String("instance_id", instanceID),
zap.Error(err))
continue
}
client := agentctl.NewClient(containerIP, instanceInfo.Port, r.logger)
recovered = append(recovered, &RuntimeInstance{
InstanceID: instanceID,
TaskID: taskID,
Client: client,
ContainerID: ctr.ID,
ContainerIP: containerIP,
WorkspacePath: "/workspace",
Metadata: map[string]interface{}{"agent_profile_id": agentProfileID},
})
r.logger.Info("recovered docker instance",
zap.String("instance_id", instanceID),
zap.String("task_id", taskID),
zap.String("container_id", ctr.ID),
zap.Int("instance_port", instanceInfo.Port))
}
return recovered, nil
}