Struct Supervisor

pkg/tools/lifecycle/supervisor.go:155–189

Supervisor manages the lifecycle of a single connection: initial connect, watcher goroutine, restart with backoff, graceful Stop. It is the shared implementation for MCP (stdio + remote) and LSP transports; per-transport behaviour is captured in the Connector. Supervisor is safe for concurrent use.

//
// Supervisor is safe for concurrent use.
type Supervisor struct {
	name      string
	connector Connector
	policy    Policy
	tracker   *Tracker

	// startMu serializes Start so two concurrent first-callers don't both
	// invoke Connector.Connect.
	startMu sync.Mutex

	// mu guards the rest of the fields.
	mu           sync.Mutex
	session      Session
	stopping     bool
	watcherAlive bool
	forceRestart bool          // set by RestartAndWait so the watcher reconnects
	restarted    chan struct{} // closed and replaced on each successful restart
	// done is closed when the supervisor enters a terminal state (Stopped
	// or Failed) so RestartAndWait can wake up promptly. Replaced with a
	// fresh channel by Start when transitioning out of a terminal state.
	done chan struct{}

	// watchDone is closed by the current watcher goroutine. Stop waits on it
	// after closing the session so no transport goroutines are left behind.
	watchDone chan struct{}

	// inflightConnect holds a connector.Connect that a startup timeout left
	// running (see connect). At most one exists at a time; the next Start
	// adopts it and Stop reaps it, so overlapping Connects never race on the
	// shared MCP session.
	inflightConnect *pendingConnect

	// randFloat is the jitter source; tests may override.
	randFloat func() float64
}

// New returns a Supervisor that drives connector with policy. The name is
// used in lifecycle log messages and should uniquely identify the toolset.