c3d235b83b
* fix(auth): scope session-keyed reads and mutations to the workspace owner Session-keyed service entry points did not apply per-user scoping, so knowing another user's session or task ID was enough to reach it: - GetTaskSession, ListTaskSessions, GetPrimarySession returned rows for any ID. These feed GET /task-sessions/:id and GET /tasks/:id/sessions, whose DTO carries session Metadata, the host worktree path, the branch, and container/executor IDs. - DismissLastAgentError mutated any session. - ApproveSession approved a workflow review step on any session, which advances the task's workflow — the highest-impact of the set. Authorize via authorizeTaskID off the row already read, rather than AuthorizeSessionAccess, which would re-read the session on what is a hot path. Internal identity-less callers (pollers, event bus, office schedulers, office agent JWTs) and the synthetic identity used while auth is disabled stay unscoped, and unowned pre-auth rows stay visible. Batch helpers that take ID lists are deliberately left alone: their callers derive IDs from an already-authorized task list, so per-ID checks would add N queries to list views for no gain. Recorded in AGENTS.md. Also route httpApproveSession through handleNotFound so a denial answers 404 like every other session route instead of a 500 that would confirm the session exists. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): scope the session-keyed paths that bypass the task service An adversarial sweep of the previous commit found session-keyed surfaces reachable with a caller-supplied ID and no ownership check. They bypass the task service, so scoping its methods did not cover them: - POST /task-sessions/:id/{set-mode,set-model,set-config-option, authenticate} and .../processes/:processId/stop resolve their execution with a bare in-memory lookup, which skips the GetOrEnsure* chokepoint where the lifecycle per-user check runs. A non-owner could switch another user's model or mode, re-authenticate their agent, or kill their process. Guarded by a shared denySessionAccess helper. - The orchestrator reads sessions through its own repo handle, so GetTaskSessionStatus and CheckSessionPR inherited nothing from the task service. CheckSessionPR also installs a PR watch as a side effect. Added a SetSessionAccessChecker hook mirroring the lifecycle manager's, wired to taskSvc.AuthorizeSessionAccess. The check runs before CheckSessionPR's unconfigured-GitHub early return so it applies regardless of setup, and denials reuse the "session not found" shape so they cannot be told apart from a missing session. - GetMessage had no scoping while ListMessages beside it did, so a caller holding another user's (session_id, message_id) pair could read their shell output. This does NOT close the whole surface. A second sweep found the orchestrator's session-mutating WS actions (session.stop/delete/rename/ set_primary/set_plan_mode/reset_context/recover/launch/ensure, agent.cancel, permission.respond) and agent.stdin / agent.resize also unscoped — agent.stdin writes arbitrary input into another user's agent process. Those touch live session lifecycle and need their own change; recorded in AGENTS.md so the gap is not mistaken for covered. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): scope every session-keyed WS action, plus a gateway backstop Completes the sweep. Dispatched WS actions were left to authorize themselves at the service layer, and a dozen never did — a caller with a guessed session ID could stop, delete, rename, relaunch or reset another user's live agent session, cancel their in-flight turn, answer their permission prompts, or write arbitrary bytes into their agent process. Two layers, deliberately both: 1. Gateway backstop. Client.authorizeAction checks any dispatched payload carrying task_id or session_id against the client's identity before dispatch. Per-method opt-in across ~74 actions in four packages had been missed repeatedly; this makes a newly added action scoped by default. Verified safe to apply generically: session_id means a task session everywhere, and user-shell/terminal actions key off task_id / task_environment_id, so nothing is misread. 2. Explicit guards, for defense in depth and for non-WS callers: - orchestrator: StopSession, DeleteSession, SetPrimarySession, RenameSession, ResetAgentContext, CancelAgent, RespondToPermission, SetSessionPlanModeByID, RecoverSession, LaunchSession, EnsureSession, CancelTransientRetry. Added SetTaskAccessChecker for the task-keyed ones. LaunchSession guards every intent at the single funnel; SessionID is empty on create, so the task check carries that case. - agent.stdin / agent.resize now call lifecycleMgr.CheckSessionAccess, the helper already documented for bare-lookup handlers. Guards go first in each method, before any repo/executor use. TestSessionKeyedEntryPointsGuardBeforeDependencies runs all twelve with nil dependencies and fails on a panic if one is placed too late. Denials are indistinguishable from a missing resource: WS returns not-found, CancelTransientRetry reports "nothing cancelled", and GetTaskSessionStatus reuses its "session not found" shape. Unwired checkers stay permissive throughout, so identity-less internal callers (schedulers, event bus, workflow engine) and pre-auth single-user instances are unaffected — pinned per entry point. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): scope environment-keyed user-shell actions Third sweep finding, in surface the previous commit's own comment claimed was covered. The user-shell actions key off task_environment_id and treat task_id as optional, so a task_id-only backstop missed them: user_shell.stop with an empty task_id and a foreign task_environment_id fell through to the legacy runner path and tore down another user's terminal PTY. That path never reaches GetOrEnsureExecutionForEnvironment, where the environment check normally runs, so neither layer caught it. - Gateway backstop now also reads task_environment_id, gated by a new AuthPolicy.ActionEnvironment hook wired to taskSvc.AuthorizeEnvironmentAccess. This covers all three environment-keyed actions generically, not just the reported one. - wsUserShellStop guards explicitly via a new lifecycleMgr.CheckEnvironmentAccess, mirroring CheckSessionAccess, so the fallback is safe independent of the gateway. Corrected the comment that wrongly asserted task_environment_id was already covered, and recorded in AGENTS.md both the exact field names the backstop reads and why a permissive type on one of them would silently opt out. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): authorize both IDs on task+session entry points Review finding (P1). Entry points taking both a task and a session ID only checked the session, so a caller could satisfy that check with one of their own sessions while pointing taskID at another user's task: - CheckSessionPR then used the unchecked taskID for GetTaskPR, resolveTaskRepo, resolvePrimaryTaskRepositoryID and EnsurePRWatch — cross-workspace PR disclosure plus a PR-watch write. - CancelTransientRetry handed it to handleRecoverableFailure, which writes against that task. Both now use a new authorizeTaskSessionPair, which authorizes each ID and additionally requires the pair to be consistent, so the two arguments cannot describe different tasks. GetTaskSessionStatus already validated the pair after loading the session and is unchanged. The consistency half is skipped when the session cannot be loaded: both IDs are authorized by then, so a mismatch is a caller bug rather than a cross-user leak, and failing there would change behavior for identity-less internal callers. Recorded the rule in AGENTS.md — a two-ID entry point must never use authorizeSession alone. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): scope AttachWorkspaceSources Found while rebasing onto main. POST /tasks/:id/workspace-sources and the add_workspace_sources_kandev MCP tool landed on main during this PR's review with no ownership check, so a caller could attach repositories and folders to another user's task and have them materialized into that task's workspace. Same class as the rest of this PR, so fixed here rather than left for a follow-up. The WS dispatch backstop added earlier already covered the browser path (the payload carries task_id); this closes the HTTP route and the MCP tool, which do not go through it. ErrTaskNotFound already maps to 404 in workspaceSourceHTTPStatus, so the denial surfaces correctly without touching the handler. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(auth): map denied shell-output reads to 404 Review finding. GetMessage became per-user scoped earlier in this PR, so a denial now arrives as ErrTaskNotFound. httpGetShellOutput only mapped sql.ErrNoRows to 404, sending everything else to the 500 branch — so a foreign message answered 500 while a missing one answered 404, which is an existence signal and inconsistent with the 404-everywhere rule the other session routes follow. Kept the sql.ErrNoRows branch explicit rather than replacing it outright: isNotFound classifies typed sentinels and the "not found" substring, and "sql: no rows in result set" matches neither, so routing that case through handleNotFound alone regressed the missing-message response to 500 (caught by TestHTTPShellOutputSnapshot). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(auth): make the shell-output scoping test actually exercise the guard Both reviewers caught that TestHTTPGetShellOutputDeniesForeignMessageWith404 was vacuous. httpGetShellOutput has a second 404 gate after the service call — `if !ok || message.TaskSessionID != c.Param("id")` — and ExtractShellExecOutput returns ok=false for nil metadata. The fixture had none, so the route answered 404 through that gate whether or not scoping denied the read. Confirmed by mutation rather than inspection: with the authorization removed from GetMessage the test still passed. With valid shell-output metadata in the fixture it returns 200 and the victim's stdout, so the test fails as intended; restoring the guard makes it pass again. Also mutation-tested the sibling denial tests, since this is a defect class rather than a one-off: - TestHTTPGetTaskSessionDeniesForeignSessionWith404 — sound, returns 200 with the session DTO when the guard is removed. - TestProcessRoutesDenyForeignSession — catches removal, though via the documented nil-lifecycleMgr panic rather than a status assertion. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * test(auth): add an in-test witness to the shell-output scoping test Review suggestion. The fixture fix made the test exercise the guard, but nothing in the test proved the 404 came from authorization rather than the route's post-service `!ok` gate — which is exactly how it went vacuous in the first place. The evidence lived in a commit message describing a manual mutation run, not in the test. Now asserts both directions, matching the approve-route test: the non-owner gets 404, and the owner does NOT. If the assertion ever stops proving authorization, the owner case fails and says so. Re-verified by mutation: removing the guard from GetMessage fails the test with 200 and the victim's stdout; restoring it passes. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Kandev Agent <agent@kandev.dev> Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
474 lines
20 KiB
Go
474 lines
20 KiB
Go
// Package lifecycle manages agent instance lifecycles including tracking,
|
|
// state transitions, and cleanup.
|
|
package lifecycle
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"go.uber.org/zap"
|
|
"golang.org/x/sync/singleflight"
|
|
|
|
"github.com/kandev/kandev/internal/agent/docker"
|
|
"github.com/kandev/kandev/internal/agent/executor"
|
|
"github.com/kandev/kandev/internal/agent/registry"
|
|
"github.com/kandev/kandev/internal/agent/runtime/activity"
|
|
agentctl "github.com/kandev/kandev/internal/agent/runtime/agentctl"
|
|
"github.com/kandev/kandev/internal/agent/runtime/routingerr"
|
|
"github.com/kandev/kandev/internal/common/logger"
|
|
"github.com/kandev/kandev/internal/events/bus"
|
|
"github.com/kandev/kandev/internal/secrets"
|
|
"github.com/kandev/kandev/internal/task/models"
|
|
"github.com/kandev/kandev/internal/worktree"
|
|
)
|
|
|
|
// ExecutorFallbackPolicy controls behavior when a requested runtime is unavailable.
|
|
type ExecutorFallbackPolicy string
|
|
|
|
const (
|
|
// ExecutorFallbackAllow silently falls back to the default runtime (current behavior).
|
|
ExecutorFallbackAllow ExecutorFallbackPolicy = "allow"
|
|
// ExecutorFallbackWarn falls back but logs a warning (current behavior, explicit).
|
|
ExecutorFallbackWarn ExecutorFallbackPolicy = "warn"
|
|
// ExecutorFallbackDeny returns an error if the requested runtime is unavailable.
|
|
ExecutorFallbackDeny ExecutorFallbackPolicy = "deny"
|
|
)
|
|
|
|
// Manager manages agent instance lifecycles
|
|
type Manager struct {
|
|
registry *registry.Registry
|
|
eventBus bus.EventBus
|
|
credsMgr CredentialsManager
|
|
profileResolver ProfileResolver
|
|
worktreeMgr *worktree.Manager
|
|
mcpProvider McpConfigProvider
|
|
logger *logger.Logger
|
|
// dataDir is the kandev root directory. Misnamed for historical reasons:
|
|
// cmd/kandev/agents.go passes cfg.ResolvedHomeDir() (the kandev root —
|
|
// typically ~/.kandev) here, not ResolvedDataDir(). Used for:
|
|
// - Session history storage (SessionHistoryManager)
|
|
// - Ephemeral workspace creation (quick chat) at <root>/quick-chat/<sessionID>
|
|
// - Scratch workspaces for repo-less tasks at <root>/tasks/<workspaceID>/<taskID>
|
|
dataDir string
|
|
|
|
// ExecutorRegistry manages multiple runtimes (Docker, Standalone, etc.)
|
|
// Each task can select its runtime based on executor type.
|
|
executorRegistry *ExecutorRegistry
|
|
|
|
// executorFallbackPolicy controls behavior when a requested runtime is unavailable.
|
|
executorFallbackPolicy ExecutorFallbackPolicy
|
|
|
|
// Refactored components for separation of concerns
|
|
executionStore *ExecutionStore // Thread-safe execution tracking
|
|
commandBuilder *CommandBuilder // Builds agent commands from registry config
|
|
sessionManager *SessionManager // Handles ACP session initialization
|
|
streamManager *StreamManager // Manages WebSocket streams
|
|
eventPublisher *EventPublisher // Publishes lifecycle events
|
|
historyManager *SessionHistoryManager // Stores session history for context injection (fork_session pattern)
|
|
|
|
// Workspace info provider for on-demand instance creation
|
|
workspaceInfoProvider WorkspaceInfoProvider
|
|
|
|
// bootMessageService creates boot messages displayed in chat during agent startup.
|
|
bootMessageService BootMessageService
|
|
|
|
// preparerRegistry maps executor types to environment preparers.
|
|
preparerRegistry *PreparerRegistry
|
|
|
|
// mcpHandler is the MCP request dispatcher for handling MCP requests
|
|
// from agentctl instances through the agent stream.
|
|
mcpHandler agentctl.MCPHandler
|
|
|
|
// sessionAccessCheck enforces per-user workspace scoping on session-scoped
|
|
// surfaces (opt-in auth). Nil = no scoping. See SetSessionAccessChecker.
|
|
sessionAccessCheck func(ctx context.Context, sessionID string) error
|
|
|
|
// environmentAccessCheck is the environment-keyed sibling of
|
|
// sessionAccessCheck, used by the terminal environment-shell route which
|
|
// resolves executions by environment ID. Nil = no scoping.
|
|
environmentAccessCheck func(ctx context.Context, environmentID string) error
|
|
|
|
// singleflight deduplicates concurrent GetOrEnsureExecution calls for the same session
|
|
ensureExecutionGroup singleflight.Group
|
|
|
|
// Background remote status polling
|
|
remoteStatusPollInterval time.Duration
|
|
remoteStatusMu sync.RWMutex
|
|
remoteStatusBySession map[string]*RemoteStatus
|
|
stopCh chan struct{}
|
|
stopOnce sync.Once
|
|
wg sync.WaitGroup
|
|
// shuttingDown is flipped true when graceful shutdown begins (see
|
|
// StopAllAgents) so handlers running in detached goroutines can
|
|
// short-circuit work that would otherwise race the teardown and log
|
|
// confusing errors against children already being stopped.
|
|
shuttingDown atomic.Bool
|
|
|
|
// pollAggregator routes hub session-mode events to agentctl. See
|
|
// manager_subscription.go.
|
|
pollAggregator *workspacePollAggregator
|
|
|
|
// secretStore encrypts/decrypts runtime auth tokens (e.g., agentctl handshake tokens).
|
|
// Used to persist tokens across backend restarts for remote executor recovery.
|
|
secretStore secrets.SecretStore
|
|
|
|
// runningWriter persists the executors_running row in lockstep with executionStore.
|
|
// See SetExecutorRunningWriter and persistence.go. The lifecycle manager is the
|
|
// only component allowed to write the lifecycle-owned columns of this table.
|
|
runningWriter ExecutorRunningWriter
|
|
|
|
// agentProfileReader resolves the full agent_profiles row (including the
|
|
// office-enrichment fields added in ADR 0005 Wave A) for the launch-prep
|
|
// SkillDeployer hook. Nil → skill deploy is skipped.
|
|
agentProfileReader AgentProfileReader
|
|
|
|
// skillDeployer materialises per-profile skills + custom prompt before
|
|
// the agent process starts. Defaults to a no-op deployer; office wires
|
|
// its concrete implementation via SetSkillDeployer.
|
|
skillDeployer SkillDeployer
|
|
|
|
// remediateNpxCache is the hook fired when the routing classifier
|
|
// returns CodeNpxCacheCorrupted. NewManager wires routingerr.RemediateNpxCache;
|
|
// tests override it to avoid touching the real filesystem.
|
|
remediateNpxCache func(path string, log *zap.Logger) error
|
|
|
|
// standaloneHostPID is the OS process id of the standalone agentctl
|
|
// control-server this backend spawned on the local host. It is the
|
|
// host-local liveness handle recorded in executors_running.local_pid for
|
|
// local/standalone rows (see persistence.go / #1597 truthful executor rows).
|
|
// 0 when unset (tests, or before the launcher wires it). Never used for
|
|
// SSH/remote rows — their process lives on another host.
|
|
standaloneHostPID atomic.Int64
|
|
|
|
// managedGoCache provides the opt-in GOCACHE for host-local executions.
|
|
// System storage wiring installs it after settings persistence is ready.
|
|
managedGoCache ManagedGoCacheEnvironmentProvider
|
|
|
|
activityCoordinator *activity.Coordinator
|
|
activityMu sync.Mutex
|
|
activityLeases map[string]*activity.TaskLease
|
|
activityLeaseOwners map[string]uint64
|
|
activityPending map[string]map[uint64]*executionActivityClaim
|
|
activityGeneration uint64
|
|
}
|
|
|
|
// ManagedGoCacheEnvironmentProvider supplies the environment for one new
|
|
// local execution. Implementations must return an absolute GOCACHE path.
|
|
type ManagedGoCacheEnvironmentProvider interface {
|
|
ExecutionEnvironment(ctx context.Context) (map[string]string, error)
|
|
}
|
|
|
|
// SetManagedGoCacheEnvironmentProvider wires install-wide managed cache settings.
|
|
func (m *Manager) SetManagedGoCacheEnvironmentProvider(provider ManagedGoCacheEnvironmentProvider) {
|
|
m.managedGoCache = provider
|
|
}
|
|
|
|
// SetActivityCoordinator wires the install-wide host-resource activity gate.
|
|
// It is optional so embedded and test configurations retain legacy behavior.
|
|
func (m *Manager) SetActivityCoordinator(coordinator *activity.Coordinator) {
|
|
m.activityMu.Lock()
|
|
m.activityCoordinator = coordinator
|
|
if m.activityLeases == nil {
|
|
m.activityLeases = make(map[string]*activity.TaskLease)
|
|
}
|
|
if m.activityLeaseOwners == nil {
|
|
m.activityLeaseOwners = make(map[string]uint64)
|
|
}
|
|
if m.activityPending == nil {
|
|
m.activityPending = make(map[string]map[uint64]*executionActivityClaim)
|
|
}
|
|
m.activityMu.Unlock()
|
|
if m.executorRegistry == nil {
|
|
return
|
|
}
|
|
backend, err := m.executorRegistry.GetBackend(executor.NameDocker)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if dockerExecutor, ok := backend.(*DockerExecutor); ok {
|
|
dockerExecutor.SetActivityCoordinator(coordinator)
|
|
}
|
|
}
|
|
|
|
// SetStandaloneHostPID records the local agentctl control-server PID so
|
|
// local/standalone executor rows can carry a real host-local liveness handle.
|
|
// Wired during DI from the agentctl launcher (see backendapp). Safe to leave
|
|
// unset in tests that don't exercise the persistence path.
|
|
func (m *Manager) SetStandaloneHostPID(pid int) {
|
|
m.standaloneHostPID.Store(int64(pid))
|
|
}
|
|
|
|
// NewManager creates a new lifecycle manager.
|
|
// The executorRegistry manages multiple runtimes (Docker, Standalone, etc.) for task-specific execution.
|
|
// The fallbackPolicy controls behavior when a requested runtime is unavailable.
|
|
func NewManager(
|
|
reg *registry.Registry,
|
|
eventBus bus.EventBus,
|
|
executorRegistry *ExecutorRegistry,
|
|
credsMgr CredentialsManager,
|
|
profileResolver ProfileResolver,
|
|
mcpProvider McpConfigProvider,
|
|
fallbackPolicy ExecutorFallbackPolicy,
|
|
dataDir string,
|
|
log *logger.Logger,
|
|
) *Manager {
|
|
componentLogger := log.WithFields(zap.String("component", "lifecycle-manager"))
|
|
|
|
// Initialize command builder
|
|
commandBuilder := NewCommandBuilder()
|
|
|
|
// Create stop channel for graceful shutdown
|
|
stopCh := make(chan struct{})
|
|
|
|
// Initialize session manager
|
|
sessionManager := NewSessionManager(log, stopCh)
|
|
|
|
// Initialize event publisher
|
|
eventPublisher := NewEventPublisher(eventBus, log)
|
|
|
|
// Initialize execution store
|
|
executionStore := NewExecutionStore()
|
|
|
|
// Initialize session history manager for fork_session pattern (context injection)
|
|
historyManager, err := NewSessionHistoryManager("", dataDir, log)
|
|
if err != nil {
|
|
log.Warn("failed to create session history manager, context injection disabled", zap.Error(err))
|
|
}
|
|
|
|
mgr := &Manager{
|
|
registry: reg,
|
|
eventBus: eventBus,
|
|
executorRegistry: executorRegistry,
|
|
executorFallbackPolicy: fallbackPolicy,
|
|
credsMgr: credsMgr,
|
|
profileResolver: profileResolver,
|
|
mcpProvider: mcpProvider,
|
|
logger: componentLogger,
|
|
dataDir: dataDir,
|
|
executionStore: executionStore,
|
|
commandBuilder: commandBuilder,
|
|
sessionManager: sessionManager,
|
|
eventPublisher: eventPublisher,
|
|
historyManager: historyManager,
|
|
remoteStatusPollInterval: 60 * time.Second,
|
|
remoteStatusBySession: make(map[string]*RemoteStatus),
|
|
stopCh: stopCh,
|
|
skillDeployer: NoopSkillDeployer(),
|
|
remediateNpxCache: routingerr.RemediateNpxCache,
|
|
}
|
|
// Initialize stream manager with callbacks that delegate to manager methods
|
|
// mcpHandler will be set later via SetMCPHandler.
|
|
// stopCh is shared with the manager so workspace-stream backoff drains on Stop.
|
|
mgr.streamManager = NewStreamManager(log, StreamCallbacks{
|
|
OnAgentEvent: mgr.handleAgentEvent,
|
|
OnStreamDisconnect: mgr.handleStreamDisconnect,
|
|
OnGitStatus: mgr.handleGitStatusUpdate,
|
|
OnGitCommit: mgr.handleGitCommitCreated,
|
|
OnGitReset: mgr.handleGitResetDetected,
|
|
OnBranchSwitch: mgr.handleBranchSwitch,
|
|
OnFileChange: mgr.handleFileChangeNotification,
|
|
OnShellOutput: mgr.handleShellOutput,
|
|
OnShellExit: mgr.handleShellExit,
|
|
OnProcessOutput: mgr.handleProcessOutput,
|
|
OnProcessStatus: mgr.handleProcessStatus,
|
|
}, nil, stopCh)
|
|
|
|
// Set session manager dependencies for full orchestration
|
|
sessionManager.SetDependencies(eventPublisher, mgr.streamManager, executionStore, historyManager)
|
|
sessionManager.SetPromptStarter(mgr.BeginPrompt)
|
|
|
|
mgr.pollAggregator = newWorkspacePollAggregator(mgr)
|
|
|
|
if executorRegistry != nil {
|
|
mgr.logger.Info("initialized with runtimes", zap.Int("count", len(executorRegistry.List())))
|
|
}
|
|
|
|
return mgr
|
|
}
|
|
|
|
// HandleSessionMode routes a session-level mode transition (from the gateway
|
|
// hub) into the per-workspace aggregator, which pushes the resulting
|
|
// workspace-effective mode to agentctl. See manager_subscription.go.
|
|
func (m *Manager) HandleSessionMode(sessionID string, mode WorkspacePollMode) {
|
|
if m.pollAggregator == nil {
|
|
return
|
|
}
|
|
m.pollAggregator.HandleSessionMode(sessionID, mode)
|
|
}
|
|
|
|
// flushCachedPollMode pushes any session mode the gateway cached before this
|
|
// execution was ready. Closes the pre-execution-focus race where the frontend
|
|
// sent session.focus during execution startup and the cached mode never
|
|
// reached agentctl. No-op when nothing was cached.
|
|
func (m *Manager) flushCachedPollMode(sessionID string) {
|
|
if m.pollAggregator == nil {
|
|
return
|
|
}
|
|
m.pollAggregator.FlushSessionMode(sessionID)
|
|
}
|
|
|
|
// SetWorktreeManager sets the worktree manager for Git worktree isolation.
|
|
//
|
|
// This must be called before launching agents if Git worktree support is enabled in the runtime.
|
|
// The worktree manager creates isolated Git working directories for each agent execution,
|
|
// allowing multiple agents to work on the same repository without conflicts.
|
|
//
|
|
// Call this during initialization, typically when setting up the orchestrator service.
|
|
// If not set, agents will work directly in the repository's main working directory.
|
|
func (m *Manager) SetWorktreeManager(worktreeMgr *worktree.Manager) {
|
|
m.worktreeMgr = worktreeMgr
|
|
// Register the worktree preparer so that executor type "worktree" gets
|
|
// worktree-specific preparation (create git worktree, checkout PR branch)
|
|
// instead of the generic local preparer.
|
|
if m.preparerRegistry != nil {
|
|
m.preparerRegistry.Register(models.ExecutorTypeWorktree, NewWorktreePreparer(worktreeMgr, m.logger))
|
|
}
|
|
}
|
|
|
|
// WorktreeManager returns the configured worktree manager. Returns nil
|
|
// when worktree support has not been wired (legacy / tests). Used by
|
|
// the office task-handoffs cleaner to translate worktree IDs into
|
|
// disk operations.
|
|
func (m *Manager) WorktreeManager() *worktree.Manager {
|
|
return m.worktreeMgr
|
|
}
|
|
|
|
// SetMCPHandler sets the MCP request handler for dispatching MCP tool calls.
|
|
//
|
|
// MCP requests from agents flow through the agent stream (WebSocket) to the backend,
|
|
// where they are dispatched to this handler. This enables agents to use MCP tools
|
|
// like listing workspaces, boards, tasks, and asking user questions.
|
|
//
|
|
// This must be called before agents start making MCP calls. Typically set during
|
|
// initialization after the MCP handlers are created.
|
|
func (m *Manager) SetMCPHandler(handler agentctl.MCPHandler) {
|
|
m.mcpHandler = handler
|
|
// Update the stream manager with the handler
|
|
m.streamManager.mcpHandler = handler
|
|
}
|
|
|
|
// SetMCPIdentityScoper installs the per-user scoping hook for in-session MCP
|
|
// tool calls.
|
|
//
|
|
// Unlike the external /mcp endpoint — where the agent presents a personal
|
|
// access token and the auth middleware resolves the identity — MCP requests
|
|
// relayed over an agent's own stream carry no credential. Without this hook
|
|
// they reach the task service with no identity, which that service reads as an
|
|
// internal caller and serves unscoped, so an agent supplying another user's
|
|
// task_id or workflow_id would be given their data.
|
|
//
|
|
// Set once during startup wiring, before agents start making MCP calls. Leave
|
|
// unset to keep dispatch unscoped (single-user instances).
|
|
func (m *Manager) SetMCPIdentityScoper(scoper MCPIdentityScoper) {
|
|
m.streamManager.mcpIdentityScoper = scoper
|
|
}
|
|
|
|
// SetSessionAccessChecker installs the per-user session visibility check used
|
|
// by GetOrEnsureExecution and EnsurePassthroughExecution. The checker must
|
|
// return nil for contexts without a request identity (internal callers). Set
|
|
// once during startup wiring, before the HTTP server accepts connections.
|
|
func (m *Manager) SetSessionAccessChecker(check func(ctx context.Context, sessionID string) error) {
|
|
m.sessionAccessCheck = check
|
|
}
|
|
|
|
// SetEnvironmentAccessChecker installs the per-user environment visibility
|
|
// check used by GetOrEnsureExecutionForEnvironment (terminal env-shell route).
|
|
func (m *Manager) SetEnvironmentAccessChecker(check func(ctx context.Context, environmentID string) error) {
|
|
m.environmentAccessCheck = check
|
|
}
|
|
|
|
// CheckSessionAccess authorizes a session-scoped operation for the ctx
|
|
// identity. Handlers that resolve an execution by a bare in-memory lookup
|
|
// (vscode/port reverse proxies) must call this before serving, since only the
|
|
// GetOrEnsure* paths run the check internally. No-op when no checker is set.
|
|
func (m *Manager) CheckSessionAccess(ctx context.Context, sessionID string) error {
|
|
if m.sessionAccessCheck == nil {
|
|
return nil
|
|
}
|
|
return m.sessionAccessCheck(ctx, sessionID)
|
|
}
|
|
|
|
// CheckEnvironmentAccess authorizes an environment-scoped operation for the ctx
|
|
// identity. The environment-keyed sibling of CheckSessionAccess, for handlers
|
|
// that act on a task environment without going through
|
|
// GetOrEnsureExecutionForEnvironment (the user-shell tear-down path).
|
|
// No-op when no checker is set.
|
|
func (m *Manager) CheckEnvironmentAccess(ctx context.Context, taskEnvironmentID string) error {
|
|
if m.environmentAccessCheck == nil {
|
|
return nil
|
|
}
|
|
return m.environmentAccessCheck(ctx, taskEnvironmentID)
|
|
}
|
|
|
|
// SetWorkspaceInfoProvider sets the provider for workspace information.
|
|
//
|
|
// The WorkspaceInfoProvider interface allows the lifecycle manager to dynamically create
|
|
// agent executions on-demand when the frontend connects to a session that doesn't have
|
|
// an active execution yet. This enables session resume after server restart or when
|
|
// accessing a session via URL (/task/[id]/[sessionId]).
|
|
//
|
|
// The provider must implement:
|
|
// - GetWorkspaceInfoBySessionID(ctx, sessionID) - Returns workspace path, worktree info,
|
|
// and MCP servers configured for the session
|
|
//
|
|
// This is typically called during initialization, with the task service as the provider.
|
|
// Without this, EnsureWorkspaceExecutionForSession will fail.
|
|
func (m *Manager) SetWorkspaceInfoProvider(provider WorkspaceInfoProvider) {
|
|
m.workspaceInfoProvider = provider
|
|
}
|
|
|
|
// SetBootMessageService sets the service used to create boot messages in chat
|
|
// during agent startup. If not set, no boot messages will be created.
|
|
func (m *Manager) SetBootMessageService(svc BootMessageService) {
|
|
m.bootMessageService = svc
|
|
}
|
|
|
|
// SetPreparerRegistry sets the registry of environment preparers.
|
|
func (m *Manager) SetPreparerRegistry(registry *PreparerRegistry) {
|
|
m.preparerRegistry = registry
|
|
}
|
|
|
|
// SetSecretStore sets the secret store for encrypting runtime auth tokens.
|
|
func (m *Manager) SetSecretStore(store secrets.SecretStore) {
|
|
m.secretStore = store
|
|
}
|
|
|
|
// SetAgentProfileReader wires the reader the launch-prep SkillDeployer uses
|
|
// to resolve full agent_profiles rows by id. Without it, the skill deploy
|
|
// step is silently skipped.
|
|
func (m *Manager) SetAgentProfileReader(reader AgentProfileReader) {
|
|
m.agentProfileReader = reader
|
|
}
|
|
|
|
// SetSkillDeployer plugs in a concrete deployer that materialises per-profile
|
|
// skills + custom prompt into the workspace before launch. Default is a
|
|
// no-op deployer; office wires its real implementation here.
|
|
func (m *Manager) SetSkillDeployer(deployer SkillDeployer) {
|
|
if deployer == nil {
|
|
m.skillDeployer = NoopSkillDeployer()
|
|
return
|
|
}
|
|
m.skillDeployer = deployer
|
|
}
|
|
|
|
// DockerClientProvider returns a function that lazily resolves the Docker client
|
|
// from the Docker executor in the registry. Returns nil if Docker is unavailable.
|
|
func (m *Manager) DockerClientProvider() func() *docker.Client {
|
|
return func() *docker.Client {
|
|
if m.executorRegistry == nil {
|
|
return nil
|
|
}
|
|
backend, err := m.executorRegistry.GetBackend(executor.NameDocker)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
dockerExec, ok := backend.(*DockerExecutor)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return dockerExec.Client()
|
|
}
|
|
}
|