monitor

type MonitorEvent ¶

type MonitorEvent struct {
	MonitorID string
	Line      string
	At        time.Time
	Closing   bool
}

MonitorEvent is one stdout line streamed by a running monitor. Closing is true on the final event when the underlying process exits (or task_stop is called) — drain folds the closing event into the system-reminder and the TUI strip flips the chip to Stopped.

type MonitorEventQueue ¶

type MonitorEventQueue struct {
	// contains filtered or unexported fields
}

MonitorEventQueue is the FIFO queue of streamed lines from every running monitor. The agent's drainMonitorEvents helper pulls events at iter start and folds them into a single <system-reminder> RoleUser message; events are never persisted beyond the drain.

func NewMonitorEventQueue() *MonitorEventQueue

func (q *MonitorEventQueue) Drain() []MonitorEvent

func (q *MonitorEventQueue) Enqueue(ev MonitorEvent)

func (q *MonitorEventQueue) HasPending() bool

type MonitorHost ¶

type MonitorHost interface {
	// MonitorTaskStore returns the agent's monitor catalog.
	MonitorTaskStore() *MonitorTaskStore
	// MonitorEventQueue returns the per-agent queue every monitor
	// streams events into.
	MonitorEventQueue() *MonitorEventQueue
	// RootCtx returns the agent-lifetime context; monitor goroutines
	// bind here, not the per-call ctx.
	RootCtx() context.Context
	// AgentID is the spawning agent's id.
	AgentID() string
	// NotifyMonitorEvent fires the agent's signal pump for one streamed
	// event. Non-blocking; the queue is the durable backstop.
	NotifyMonitorEvent(ev MonitorEvent)
}

MonitorHost is the narrow surface a MonitorTool reads from its host (*toolset.ToolState in production). Mirrors shell.BgTaskHost so the two implementations stay parallel.

type MonitorStatus ¶

type MonitorStatus string

MonitorStatus is the lifecycle state of one Monitor task. Distinct from shell.BgTaskStatus because monitor tasks can be long-lived (persistent loops) and don't carry a single exit code — they accumulate events.

Transitions:

Monitoring → Stopped   (process exited cleanly OR task_stop called)
Monitoring → Failed    (process spawn failed)

const (
	Monitoring MonitorStatus = "monitoring"
	Stopped    MonitorStatus = "stopped"
	Failed     MonitorStatus = "failed"
)

type MonitorTask ¶

type MonitorTask struct {
	MonitorTaskSnapshot
	Cancel context.CancelFunc
}

MonitorTask is the live record the store mutates. Cancel terminates the underlying process — task_stop calls it; the goroutine then transitions the snapshot to Stopped.

type MonitorTaskSnapshot ¶

type MonitorTaskSnapshot struct {
	ID          string
	Command     string
	Description string
	Status      MonitorStatus
	EventCount  int
	StartedAt   time.Time
	StoppedAt   time.Time
	AgentID     string
}

MonitorTaskSnapshot is the public shape of one monitor entry. The event count is read at snapshot time; events themselves live in the per-agent MonitorEventQueue, not on the snapshot.

type MonitorTaskStore ¶

type MonitorTaskStore struct {
	*observable.Observable
	// contains filtered or unexported fields
}

MonitorTaskStore is the agent-owned catalog of monitor tasks. Same shape as shell.BgTaskStore: embedded Observable for TUI fanout, internal mutex, lifecycle methods (Add / Complete / Stop) + query methods (Get / Snapshot).

Unlike BgTaskStore there is no DrainCompleted — monitors don't fold their snapshot into the conversation when they stop. The per-monitor closing event (Closing:true) carries that signal; the snapshot just transitions to Stopped/Failed and stays in the store until the session ends.

func NewMonitorTaskStore() *MonitorTaskStore

func (s *MonitorTaskStore) Add(snap MonitorTaskSnapshot, cancel context.CancelFunc)

func (s *MonitorTaskStore) Complete(id string, status MonitorStatus)

func (s *MonitorTaskStore) Domain() string

func (s *MonitorTaskStore) Get(id string) (MonitorTaskSnapshot, bool)

func (s *MonitorTaskStore) IncEventCount(id string)

func (s *MonitorTaskStore) Snapshot() []MonitorTaskSnapshot

func (s *MonitorTaskStore) Stop(id string) (MonitorTaskSnapshot, bool)

type MonitorTool ¶

type MonitorTool struct {
	// contains filtered or unexported fields
}

MonitorTool spawns a long-running shell command and streams its stdout lines back to the agent as MonitorEvents. host supplies the MonitorTaskStore + event queue + signal sender; without it the tool reports a clean error rather than panicking.

func NewMonitor(host MonitorHost) *MonitorTool

func (t *MonitorTool) Description() string

func (t *MonitorTool) Execute(_ context.Context, logger *slog.Logger, raw json.RawMessage) (tools.Result, error)

func (t *MonitorTool) Name() string

func (t *MonitorTool) Schema() json.RawMessage