coder

type Activity ¶

type Activity struct {
	// Text is what the session last did, newest last, bounded to what a reader
	// can take in.
	Text string
	// Finished says the session's turn is over: it is waiting, not working.
	Finished bool
	// Screen says Text is the terminal picture rather than a recorded
	// conversation, so it carries the coder's input line and whatever draft
	// stands in it. A reader has to be told that, because a draft is not a
	// message.
	Screen bool
}

Activity is what a coder says about one of its sessions without attaching to it: what it last did, and whether it is still doing something. Why it stopped is not answered here and cannot be: a coder waiting on a dialog, one with no room left to think in and one that is simply done all look the same from outside, and telling them apart takes reading the screen and understanding it. That is what the check does, with the screen in front of it.

type ActivityReporter ¶

type ActivityReporter interface {
	SessionActivity(sessionID string, entries, budget int) (Activity, error)
}

ActivityReporter is the optional capability of a coder to report a session's activity from its own records. A coder implements it when its CLI keeps a record of the session on disk; for a coder that keeps none, the manager falls back to the terminal picture, which is the only source left.

entries is how many recorded messages the reading keeps, newest last; zero or less means the coder's own default. budget is how many runes the whole reading may cost; zero or less means unlimited, and a message the budget cuts has to say in the text how much of it is shown, never end in a bare ellipsis. Fewer entries leave more room per message within the same budget.

type Agent ¶

type Agent struct {
	ID           string
	Description  string
	Instructions string
	Path         string
}

Agent is a stored coder-specific agent definition.

type AgentOption ¶

type AgentOption struct {
	Value string
	Label string
}

AgentOption is a UI-friendly choice for the agent dropdown.

type AgentRepository ¶

type AgentRepository interface {
	List() []Agent
	Options() []AgentOption
	Find(rawID string) (Agent, error)
	ValidateSelected(rawID string) (string, error)
	Save(originalRawID, rawID, rawDesc, rawInstr string) (AgentSaveResult, error)
	Delete(rawID string) (Agent, error)
}

AgentRepository manages coder-specific stored agents.

func NewStandardAgentRepository(dir, fileSuffix string) AgentRepository

type AgentSaveResult ¶

type AgentSaveResult struct {
	Saved   Agent
	Created bool
}

AgentSaveResult conveys what happened when saving an agent.

type AssistantCapable ¶

type AssistantCapable interface {
	AssistantRunner() assistant.Runner
}

AssistantCapable is the optional conversation capability. A coder implements it when its CLI can answer a prompt non-interactively and stream the answer; the method returns nil when the installed version cannot. Terminal behavior does not depend on it, a coder without it keeps every other surface.

The dependency points this way on purpose: internal/assistant never imports internal/coder, so the two packages cannot form a cycle.

type CapabilityProbe ¶

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

CapabilityProbe caches an expensive check of an installed CLI. A pass is final for the life of the process, the binary does not lose a flag while the server runs. A miss is retried once the pause is over, because a failed probe often describes the moment rather than the CLI, for example an update replacing the binary right when the probe ran. Freezing that first impression would keep the capability off until the next server restart.

func NewCapabilityProbe(check func() bool, pause time.Duration) *CapabilityProbe

func (p *CapabilityProbe) Passed() bool

type CockpitInstance ¶

type CockpitInstance struct {
	Executable string
	StateDir   string
	Running    func(stateDir string) bool
}

CockpitInstance is the instance a managed skill is rendered for and belongs to: what to run, which cockpit it reaches, and the one question that cannot be answered from a file.

Running answers whether another instance is still serving from a state directory, and it is what tells the two cases apart that look identical on the disk: a second cockpit running right now beside this one, and this same cockpit restarted with a different --state-dir. The first one owns the skill and keeps it, the second left nothing behind but the mark of a state directory nobody serves from any more, and that one is taken over. Nil reads as nobody serving, so a caller that does not ask takes the skill over.

type Coder ¶

type Coder interface {
	ID() string
	RequiredTools() []string
	AgentRepository() AgentRepository
	SessionRepository() SessionRepository
	SkillRepository() SkillRepository
	GlobalInstructions() GlobalInstructions
	SessionRuntime() SessionRuntime
	ControlMapper() terminal.ControlMapper
}

Coder is a dependency bag for coder-specific collaborators.

type GlobalInstructions ¶

type GlobalInstructions interface {
	Read() (string, error)
	Save(raw string) error
}

GlobalInstructions reads and writes coder-wide instructions.

func NewFileGlobalInstructions(filePath string) GlobalInstructions

type Manager ¶

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

Manager orchestrates the session lifecycle.

func NewManager(
	cfg config.Config,
	t *tmux.Client,
	p Coder,
	projects *project.Repository,
) *Manager

func (s *Manager) Activity(rawID string, entries, budget int) (Activity, error)

func (s *Manager) AttachStream(rawID, rawCols, rawRows string) (terminal.Attachment, error)

func (s *Manager) Coder() Coder

func (s *Manager) DeleteResumable(rawID string) (Session, error)

func (s *Manager) DetachStream(name string)

func (s *Manager) ID() string

func (s *Manager) Invalidate()

func (s *Manager) OwnsStream(rawID string) bool

func (s *Manager) RefreshStream(name string, generation int64) (terminal.Attachment, bool)

func (s *Manager) Resize(rawID, rawCols, rawRows string) error

func (s *Manager) Resnapshot(name string) (terminal.Attachment, bool)

func (s *Manager) Resolve(rawID string) error

func (s *Manager) ResolveResumable(rawID string) (Session, error)

func (s *Manager) ResolveRunning(rawID string) (Running, error)

func (s *Manager) Resume(rawID string) (Session, error)

func (s *Manager) ResumeReserved(rawSessionID, rawWorkdir, title string) (Session, error)

func (s *Manager) RunBellWatch(interval time.Duration, onBell func(targetID string))

func (s *Manager) Send(rawID string, items []terminal.Input) error

func (s *Manager) SetHidden(hidden func(sessionID string) bool)

func (s *Manager) Snapshot() Snapshot

func (s *Manager) Start(rawName, rawProject, rawAgent string, opts StartOptions) (StartResult, error)

func (s *Manager) Stop(rawID string) (string, error)

func (s *Manager) StopIdleStreams() error

func (s *Manager) StreamDelta(name string, offset int64) ([]byte, int64, bool)

func (s *Manager) StreamExited(name string) bool

func (s *Manager) StreamModes(name string) (tmux.PaneModes, bool)

func (s *Manager) StreamUpdated(name string) (<-chan struct{}, bool)

type Registry ¶

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

func NewRegistry(ps ...Coder) *Registry

func (r *Registry) All() []Coder

func (r *Registry) ByID(rawID string) Coder

func (r *Registry) IDs() []string

type Running ¶

type Running struct {
	Identifier   string // stable session ID used in URLs/UI
	TmuxSession  string // underlying tmux session name
	PID          string
	Name         string
	StartedAt    time.Time
	CWD          string
	TabPos       int    // tab strip position from @dc_tab_pos, 0 when unset
	TabGroup     string // split view group id from @dc_tab_group, empty when ungrouped
	TabGroupPos  int    // position inside the group from @dc_tab_gpos, 0 when unset
	TabGroupName string // group display name from @dc_tab_gname, may be empty
	TabGroupCol  int    // column inside the group from @dc_tab_gcol, 0 for a column of its own
}

Running is one live tmux session backed by a recognised coder process.

type Session ¶

type Session struct {
	SessionID string
	Name      string
	CWD       string
	UpdatedAt time.Time
}

Session is one stored coder-CLI session that can be resumed.

type SessionRepository ¶

type SessionRepository interface {
	List() []Session
	DeleteSession(sessionID string) error
	ListFiles(sessionID string) ([]filesystem.File, error)
	SaveFile(sessionID, rawName string, src io.Reader) (filesystem.File, error)
	OpenFile(sessionID, rawName string) (filesystem.OpenedFile, error)
	DeleteFile(sessionID, rawName string) (filesystem.File, error)
}

SessionRepository manages coder-specific persisted sessions and files.

type SessionRuntime ¶

type SessionRuntime interface {
	UsesProvidedSessionID() bool
	StartCommand(start SessionStart) string
	ResumeCommand(sessionID, workdir string, automaticApproval bool) string
	Env() map[string]string
}

SessionRuntime builds coder-specific start and resume commands.

type SessionStart ¶

type SessionStart struct {
	SessionID         string
	Name              string
	Workdir           string
	AgentID           string
	AutomaticApproval bool
	Task              string
}

SessionStart is what a new coder session needs to come up. Task is optional: when it is set the CLI is started with that first prompt in its argv, which is the only delivery that cannot be lost. Typing into a pane that has not read stdin yet loses the text without a trace.

type Skill ¶

type Skill struct {
	ID           string
	Description  string
	Instructions string
	Path         string
}

Skill is a stored coder-specific global skill definition.

type SkillRepository ¶

type SkillRepository interface {
	List() []Skill
	Find(rawID string) (Skill, error)
	Save(originalRawID, rawID, rawDesc, rawInstr string) (SkillSaveResult, error)
	Delete(rawID string) (Skill, error)
}

SkillRepository manages coder-specific global skills.

func NewStandardSkillRepository(dir string) SkillRepository

type SkillSaveResult ¶

type SkillSaveResult struct {
	Saved   Skill
	Created bool
}

SkillSaveResult conveys what happened when saving a skill.

type Snapshot ¶

type Snapshot struct {
	Running   []Running
	Inactive  []Session
	Resumable []Session // every stored session, including those already running
}

Snapshot captures the present state of every session category.

type StartOptions ¶

type StartOptions struct {
	AutomaticApproval bool
	// Task is the first prompt the session comes up with. It travels in the
	// CLI's argv, never typed into the pane, so it cannot be lost to a CLI that
	// has not read stdin yet.
	Task string
}

StartOptions control how a new provider session is launched.

type StartResult ¶

type StartResult struct {
	Identifier string
	Name       string
	Workdir    string
	AgentID    string
}

StartResult is returned by Start.

type WorkdirTruster ¶

type WorkdirTruster interface {
	TrustWorkdir(workdir string) error
}

WorkdirTruster is the optional capability of a coder runtime to record a working directory as trusted in the CLI's own configuration, the way the CLI records it after its trust dialog was answered.

It exists because a coder that comes up in a directory its CLI has never seen asks "do you trust the files in this folder?" before it reads anything else, and the task travels in the argv: the session sits on a dialog with the work behind it while the caller was told the coder is working. There is no flag for it on either CLI, the answer is state in the CLI's own config, so this writes what the dialog would have written. A runtime whose CLI has no such state leaves the method out.