api

type ActiveChatLister ¶ added in v0.1.68

type ActiveChatLister interface {
	ActiveChatChannelIDs() map[string]struct{}
}

ActiveChatLister returns channel IDs with active chat agent runs.

type ChannelCreator ¶

type ChannelCreator interface {
	CreateChannel(ctx context.Context, name string) (string, error)
	InviteUserToChannel(ctx context.Context, channelID, userID string) error
	GetOwnerUserID(ctx context.Context) (string, error)
	SetChannelTopic(ctx context.Context, channelID, topic string) error
}

ChannelCreator can create channels on the chat platform.

type ChannelEnsurer ¶

type ChannelEnsurer interface {
	EnsureChannel(ctx context.Context, dirPath, platform string) (string, error)
	CreateChannel(ctx context.Context, name, authorID, sourceChannelID, platform string) (string, error)
	EnsureChannelAllPlatforms(ctx context.Context, dirPath string) ([]EnsureResult, error)
}

ChannelEnsurer resolves a directory path to a channel ID, creating the channel if it does not yet exist.

func NewChannelService(store db.Store, creators map[types.Platform]ChannelCreator) ChannelEnsurer

type ChannelLister ¶ added in v0.1.15

type ChannelLister interface {
	ListChannels(ctx context.Context) ([]*db.Channel, error)
	GetChannel(ctx context.Context, channelID string) (*db.Channel, error)
	GetMessagesCursor(ctx context.Context, channelID string, cursor int64, limit int) ([]*db.Message, error)
	SearchMessages(ctx context.Context, query string, limit int) ([]*db.Message, error)
	GetMessagesAround(ctx context.Context, channelID string, messageID int64, limit int) ([]*db.Message, error)
	DeleteChannel(ctx context.Context, channelID string) error
	DeleteChannelsByParentID(ctx context.Context, parentID string) error
	ListDistinctMemoryFilePaths(ctx context.Context, dirPath string) ([]db.MemoryFileInfo, error)
}

ChannelLister can list, look up, and delete channels and their messages from the database.

type ContainerFinder ¶ added in v0.1.68

type ContainerFinder interface {
	FindContainerByChannel(ctx context.Context, channelID, dirPath string) (string, error)
}

ContainerFinder resolves a channel ID to a running container ID.

type ContainerStopper ¶ added in v0.1.68

type ContainerStopper interface {
	ContainerRemove(ctx context.Context, containerID string) error
}

ContainerStopper removes a container by ID.

type EnsureResult ¶ added in v0.2.0

type EnsureResult struct {
	Platform  types.Platform `json:"platform"`
	ChannelID string         `json:"channel_id"`
	Created   bool           `json:"created"`
}

EnsureResult describes the outcome of ensuring a channel for one platform.

type Event ¶ added in v0.1.68

type Event struct {
	Type      string `json:"type"`
	ChannelID string `json:"channel_id"`
	Data      any    `json:"data"`
	Timestamp int64  `json:"timestamp"`
}

Event represents a server-sent event to WebSocket clients.

type EventsHub ¶ added in v0.1.68

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

EventsHub manages WebSocket event subscribers and broadcasts events.

Thread-safety: The hub's subscriber set is protected by mu (RWMutex). Broadcast takes a snapshot of subscribers under RLock, then releases the lock before writing to each connection. Each connection has its own writeMu to serialize writes. This means a concurrent Unregister may remove a subscriber that Broadcast is about to write to — this is safe because writeMu still guards the connection, and a failed write triggers Unregister (idempotent delete from the map).

func NewEventsHub(logger *slog.Logger) *EventsHub

func (h *EventsHub) Broadcast(evt Event)

func (h *EventsHub) BroadcastAgentActivity(channelID string, data events.AgentActivityEventData)

func (h *EventsHub) BroadcastAgentStatus(channelID string, data events.AgentStatusEventData)

func (h *EventsHub) BroadcastChannelCreated(parentChannelID, channelID string)

func (h *EventsHub) BroadcastChannelDeleted(channelID string)

func (h *EventsHub) BroadcastMessageCreated(channelID string, data events.MessageEventData)

func (h *EventsHub) BroadcastMessageStreaming(channelID string, data events.MessageStreamingData)

func (h *EventsHub) BroadcastToolUse(channelID string, data events.ToolUseEventData)

func (h *EventsHub) Register(conn *websocket.Conn, channels []string) *eventConn

func (h *EventsHub) Unregister(ec *eventConn)

type IncomingMessageHandler ¶ added in v0.1.68

type IncomingMessageHandler interface {
	HandleIncomingMessage(ctx context.Context, channelID, authorID, content, mode string)
	HandleThreadCreated(ctx context.Context, threadID, authorID, message string)
}

IncomingMessageHandler processes a user message from the API, routing it through the orchestrator so Claude can respond.

type InteractionHandler ¶ added in v0.1.68

type InteractionHandler interface {
	HandleInteraction(ctx context.Context, inter *bot.Interaction)
}

InteractionHandler processes a parsed slash command interaction.

type InteractiveCmdBuilder ¶ added in v0.1.68

type InteractiveCmdBuilder interface {
	BuildInteractiveCmd(channelID, dirPath, sessionID string, forkSession bool) string
}

InteractiveCmdBuilder builds the interactive Claude command for a terminal session.

type MemoryIndexer ¶ added in v0.1.33

type MemoryIndexer interface {
	Search(ctx context.Context, memoryDir, query string, topK int) ([]memory.SearchResult, error)
	Index(ctx context.Context, memoryDir string) (int, error)
}

MemoryIndexer abstracts memory search and indexing for the memory API endpoints.

type MessageSender ¶ added in v0.1.15

type MessageSender interface {
	PostMessage(ctx context.Context, channelID, content string) error
}

MessageSender can send messages to channels or threads.

type RunningChannelLister ¶ added in v0.1.68

type RunningChannelLister interface {
	RunningChannelIDs(ctx context.Context) (map[string]struct{}, error)
}

RunningChannelLister returns the set of channel IDs that have running containers.

type Server ¶

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

Server exposes a lightweight HTTP API for task CRUD operations.

func NewServer(sched scheduler.Scheduler, channels ChannelEnsurer, threads ThreadEnsurer, store ChannelLister, messages MessageSender, logger *slog.Logger) *Server

func (s *Server) EventsHub() *EventsHub

func (s *Server) SetActiveChatLister(lister ActiveChatLister)

func (s *Server) SetContainerFinder(finder ContainerFinder)

func (s *Server) SetContainerStopper(stopper ContainerStopper)

func (s *Server) SetEventsHub(hub *EventsHub)

func (s *Server) SetHostTerminalManager(mgr TerminalManager)

func (s *Server) SetIncomingMessageHandler(h IncomingMessageHandler)

func (s *Server) SetInteractionHandler(h InteractionHandler)

func (s *Server) SetInteractiveCmdBuilder(builder InteractiveCmdBuilder)

func (s *Server) SetLoopDir(dir string)

func (s *Server) SetMemoryIndexer(idx MemoryIndexer)

func (s *Server) SetRunningChannelLister(lister RunningChannelLister)

func (s *Server) SetStopError(err error)

func (s *Server) SetTerminalManager(mgr TerminalManager)

func (s *Server) Start(addr string) error

func (s *Server) Stop(ctx context.Context) error

type TerminalManager ¶ added in v0.1.68

type TerminalManager interface {
	CreateSession(ctx context.Context, containerID string, cmd []string) (sessionID string, output <-chan []byte, history []byte, done <-chan struct{}, err error)
	AttachSession(sessionID string) (output <-chan []byte, history []byte, done <-chan struct{}, err error)
	DetachSession(sessionID string, output <-chan []byte) error
	SendInput(sessionID string, data []byte) error
	Resize(ctx context.Context, sessionID string, rows, cols uint) error
	StopSession(sessionID string) (containerID string, err error)
}

TerminalManager abstracts the terminal session operations needed by the handler.

type ThreadCreator ¶ added in v0.1.11

type ThreadCreator interface {
	CreateThread(ctx context.Context, channelID, name, mentionUserID, message string) (string, error)
	DeleteThread(ctx context.Context, threadID string) error
}

ThreadCreator can create and delete threads on the chat platform.

type ThreadEnsurer ¶ added in v0.1.11

type ThreadEnsurer interface {
	CreateThread(ctx context.Context, channelID, name, authorID, message string) (string, error)
	DeleteThread(ctx context.Context, threadID string) error
}

ThreadEnsurer manages threads on the chat platform and the DB.

func NewThreadService(store db.Store, creator ThreadCreator, logger *slog.Logger) ThreadEnsurer