livesessions

type Activity struct {
	// Steps are the latest tool calls, oldest first, at most maxSteps.
	Steps []Step `json:"steps,omitempty"`
	// FilesTouched is the number of distinct files the session wrote, over
	// the whole transcript read so far; absent when none.
	FilesTouched int `json:"files_touched,omitempty"`
	// LastMessage is the latest assistant text, masked, its line breaks kept
	// (block) and cut.
	LastMessage string `json:"last_message,omitempty"`
	// LastPrompt is the latest message the user typed, masked, on one line
	// and cut.
	LastPrompt string `json:"last_prompt,omitempty"`
	// contains filtered or unexported fields
}

type Answer struct {
	Session Session
	// Version changes whenever the transcript's files do.
	Version string
	// Body is the rendered transcript.
	Body []byte
	// Images are the media types of the images pasted with each prompt, by
	// its turn, in order; nil when none were.
	Images map[string][]string
	// contains filtered or unexported fields
}

type ClaudeAlive struct {
	Home string
}

type ClaudeExit struct {
	// Home holds ~/.claude; empty is the user's home.
	Home string
}

type ClaudeInbox struct {
	// Home holds ~/.claude; empty is the user's home.
	Home string
}

type ClaudeProcess struct {
	PID       int    `json:"pid"`
	SessionID string `json:"sessionId"`
	// Status is "idle" or "busy".
	Status string `json:"status"`
	// Socket is the session's cross-session inbox, a Unix socket.
	Socket string `json:"messagingSocketPath"`
	Kind   string `json:"kind"`
	// ProcStart is when the process started as its system counts it (on
	// Linux, field 22 of /proc/<pid>/stat), and PIDDomain the pid namespace
	// the pid is in ("linux::pid:[…]"): Claude Code records both, so a pid a
	// later process reused, under an entry a killed session left, is told
	// apart from the session's own.
	ProcStart string `json:"procStart"`
	PIDDomain string `json:"pidDomain"`
}

type CodexQueue struct {
	// Codex is the codex command, looked up on PATH when the daemon starts.
	Codex string
}

type Discovery interface {
	Cached(context.Context, github.Repository) (discovery.Snapshot, error)
}

type Ender func(ctx context.Context, id string) error

type Focuser interface {
	Predict(agent string, terminal *hookevents.Terminal) string
	Focus(ctx context.Context, agent, id string, terminal *hookevents.Terminal) focus.Result
}

type Link struct {
	// Repository is the registered clone's repository, "owner/name" in
	// lower case.
	Repository string
	// Branch is the branch checked out, empty when detached.
	Branch string
	// PR is the pull request of Branch, 0 when none is known.
	PR                                 int
	PRState                            string
	HeadSHA, Upstream, Method, Status  string
	HeadRepository, UpstreamRepository string
}

type Linker interface {
	Link(ctx context.Context, cwd string) (Link, bool)
}

type Listed struct {
	Session
	// Title is the session's name as its agent shows it: Claude Code's title
	// (the one the user set, else the one it generated), Codex's thread
	// name, Cursor's conversation name; else the session's first prompt.
	// One line, masked as transcripts are. Empty only when the agent's
	// files cannot be read.
	Title string `json:"title,omitempty"`
	// Summary is the opening of the session's latest compaction summary (its
	// first section), one line, masked; absent until the agent compacted the
	// session. The transcript route serves the whole summary.
	Summary string `json:"summary,omitempty"`
	// Activity is what the transcript says the session is doing: its latest
	// tool calls, how many files it wrote and its latest message (see
	// Activity). Absent for Cursor sessions and until a transcript has a tool
	// call or assistant text.
	Activity *Activity `json:"activity,omitempty"`
	// Endable is whether the app may end the session (end.go): it waits on
	// its user or went quiet, and baum can stop its agent.
	Endable bool `json:"endable,omitempty"`
	// Messageable is whether the app may send the session a message
	// (message.go): it waits at its prompt, and baum can reach its agent.
	Messageable bool `json:"messageable,omitempty"`
	// Focus is how precisely the focus route can bring the session forward:
	// "session" for its own tab, pane or conversation, "window" for the
	// window or application it runs in. Absent when it cannot, as for a
	// session that ended or whose hooks did not say where it runs.
	Focus string `json:"focus,omitempty"`
}

type Location struct {
	Vendor vendors.Slug
	// ID is the session's id: Cursor's conversation.
	ID string
	// contains filtered or unexported fields
}

type RecordedLinker interface {
	Relink(context.Context, Session) (Link, bool)
}

type Registry interface {
	List(context.Context) ([]repos.Clone, error)
}

type Resolver struct {
	Registry  Registry
	Discovery Discovery
	// Now is the clock; nil is time.Now.
	Now func() time.Time
	// contains filtered or unexported fields
}

type Sender func(ctx context.Context, id, text string) error

type Session struct {
	Agent string `json:"agent"`
	ID    string `json:"session_id"`
	State string `json:"state"`
	// StartedAt is the session's start event, or its first event the
	// daemon saw when it did not see the start.
	StartedAt      time.Time `json:"started_at"`
	LastActivityAt time.Time `json:"last_activity_at"`
	// LastPromptAt is the latest prompt event, absent before the daemon saw
	// one: what the Sessions page orders running sessions by, as their
	// activity moves with each tool call.
	LastPromptAt time.Time `json:"last_prompt_at,omitzero"`
	// LastEvent is the normalised kind of the latest event (EventStart,
	// EventPrompt, EventTool, EventWait, EventStop or EventEnd).
	LastEvent string `json:"last_event"`
	// WaitingReason is why the session waits on its user (WaitPermission,
	// WaitInput or WaitTurnFinished), absent while it works, once it ended,
	// and for a session that is only silent.
	WaitingReason string `json:"waiting_reason,omitempty"`
	// WaitingSince is when that wait began.
	WaitingSince time.Time `json:"waiting_since,omitzero"`
	// WaitingMessage is the line a Claude Code notification showed for the
	// wait, such as "Claude needs your permission to use Bash": format and
	// control characters dropped, masked as transcripts are and at most
	// maxWaitingMessage characters. Absent when the agent sent none.
	WaitingMessage string `json:"waiting_message,omitempty"`
	// EndedAt is when an ended session sent its end event, absent otherwise.
	EndedAt    time.Time `json:"ended_at,omitzero"`
	Repository string    `json:"repository"`
	Branch     string    `json:"branch,omitempty"`
	// PR is the pull request whose head is Branch, 0 when there is none
	// (yet) or it cannot be told.
	PR                 int          `json:"pr,omitempty"`
	PRState            string       `json:"pr_state,omitempty"`
	HeadSHA            string       `json:"head_sha,omitempty"`
	Upstream           string       `json:"upstream,omitempty"`
	HeadRepository     string       `json:"head_repository,omitempty"`
	UpstreamRepository string       `json:"upstream_repository,omitempty"`
	LinkMethod         string       `json:"link_method,omitempty"`
	LinkStatus         string       `json:"link_status,omitempty"`
	ObservedAt         time.Time    `json:"observed_at,omitzero"`
	WorkHistory        *WorkHistory `json:"work_history,omitempty"`
}

type Source interface {
	Recent(limit int) ([]hookevents.Record, error)
	SubscribeCounted(buffer int, match func(hookevents.Event) bool) (events <-chan hookevents.Record, cancel func(), dropped func() uint64)
}

type Step struct {
	Tool   string `json:"tool"`
	Target string `json:"target,omitempty"`
	At     string `json:"at,omitempty"`
}

type Tracker struct {
	Source Source
	Linker Linker
	// Notify is called, coalesced to at most one call per NotifyEvery, after
	// the sessions changed. It must not block.
	Notify func()
	Log    *slog.Logger
	// Now is the clock; nil is time.Now.
	Now func() time.Time
	// StateDir, when set, is a private directory where live and ended
	// observations are kept across restarts (StateFile): no local paths or
	// notification message text. An open one silent for DropAfter is restored
	// only while Alive says its agent runs.
	StateDir string
	// Alive, when set, reports whether a session's agent still runs: true
	// only for a process it confirms is the session's. A session silent for
	// DropAfter stays listed while it does, as one waiting for its user may be
	// answered hours later; nil drops it then.
	Alive func(agent, id string) bool
	// Buffer is the subscription's size; zero is 256. A subscriber that falls
	// behind misses events, which Reconcile applies from the record once the
	// subscription reports it missed some.
	Buffer int
	// Mask, when set, masks the secrets and e-mail addresses in a waiting
	// message, as transcripts are masked; nil keeps the text.
	Mask func(string) string
	// Waiting, when set, is called once for each wait for a permission or an
	// answer (WaitPermission, WaitInput) of a session the application is
	// shown, as it begins: not for a finished turn, not for the waits a
	// rebuild replays when the daemon starts, and not for one that began more
	// than AnnounceWithin ago. It is called without the tracker's lock and
	// must not block.
	Waiting func(Session)
	// contains filtered or unexported fields
}

type Transcripts struct {
	Tracker *Tracker
	// Render writes a session's transcript; transcript.Renderer.Render is
	// the one every local transcript is written with.
	Render func(ctx context.Context, graph *session.Graph, meta transcript.Meta) ([]byte, error)
	// Home holds the agents' session stores; empty is the user's home.
	Home string
	// CursorStore is Cursor's database; empty is its default global store.
	CursorStore string
	// Now is the clock; nil is time.Now.
	Now func() time.Time
	Log *slog.Logger
	// Enders stop a session's agent, by agent (end.go); an agent without
	// one cannot be ended from the app.
	Enders map[string]Ender
	// Senders put a message from the app into a session, by agent
	// (message.go); an agent without one cannot be messaged.
	Senders map[string]Sender
	// Focus brings a running session forward; nil serves no focus route and
	// lists no session as one it can bring forward.
	Focus Focuser
	// contains filtered or unexported fields
}

type Unavailable struct{ Reason string }

type WorkHistory struct {
	Entries []WorkObservation `json:"entries"`
}

type WorkLinker interface {
	// LinkCommit links the commit head made on branch ("" when detached) in
	// the working tree dir, from what the hook recorded rather than what dir
	// has checked out now, and reports false when dir is in no registered
	// clone.
	LinkCommit(ctx context.Context, dir, branch, head string) (Link, bool)
	// LinkPush links a push from the working tree dir through remote, of
	// head to branch, and reports false when dir is in no registered clone.
	LinkPush(ctx context.Context, dir, remote, branch, head string) (Link, bool)
}

type WorkObservation struct {
	At                 time.Time `json:"at"`
	HeadRepository     string    `json:"head_repository,omitempty"`
	UpstreamRepository string    `json:"upstream_repository,omitempty"`
	Repository         string    `json:"repository"`
	Branch             string    `json:"branch,omitempty"`
	HeadSHA            string    `json:"head_sha,omitempty"`
	Upstream           string    `json:"upstream,omitempty"`
	PR                 int       `json:"pr,omitempty"`
}