package server import ( "context" "errors" "sort" "sync" "git.a-wan.net/alan/pipelines/internal/codex" "git.a-wan.net/alan/pipelines/internal/protocol" ) // chatManager routes one session to the harness that owns it. OpenCode remains // the default; Codex is attached when its app-server control socket exists. // The operator registry is the durable record of the backend, so a restart does // not have to guess from a session id. type chatManager struct { opencode chatBroker codex chatBroker registry operatorRegistry mu sync.Mutex cache map[string]string // session id -> backend } func NewChatManager(ctx context.Context, open chatBroker, registry operatorRegistry) *chatManager { m := &chatManager{opencode: open, registry: registry, cache: map[string]string{}} if codex.Available() { client, err := codex.Open(ctx) if err == nil { m.codex = client } } return m } // Close releases the owned Codex client, if any. func (m *chatManager) Close() { if closer, ok := m.codex.(interface{ Close() }); ok { closer.Close() } } // Backends lists the harnesses available for a new session. func (m *chatManager) Backends() []string { backends := []string{} if m.opencode != nil { backends = append(backends, "opencode") } if m.codex != nil { backends = append(backends, codex.Backend) } sort.Strings(backends) return backends } func (m *chatManager) adapter(backend string) chatBroker { switch backend { case "", "opencode": return m.opencode case codex.Backend: return m.codex default: return nil } } func (m *chatManager) backendFor(ctx context.Context, sessionID string) string { m.mu.Lock() backend := m.cache[sessionID] m.mu.Unlock() if backend != "" { return backend } if m.registry != nil { if row, found, err := m.registry.OperatorSession(ctx, sessionID); err == nil && found && row.Backend != "" { m.mu.Lock() m.cache[sessionID] = row.Backend m.mu.Unlock() return row.Backend } } return "opencode" } func (m *chatManager) brokerFor(ctx context.Context, sessionID string) (chatBroker, error) { backend := m.backendFor(ctx, sessionID) adapter := m.adapter(backend) if adapter == nil { return nil, errors.New("chat backend " + backend + " is not available") } return adapter, nil } // CreateBackend creates a session on the requested harness. An empty backend // keeps the OpenCode default. func (m *chatManager) CreateBackend(ctx context.Context, title, directory, backend string) (protocol.ChatSession, error) { if backend == "" { backend = "opencode" } adapter := m.adapter(backend) if adapter == nil { return protocol.ChatSession{}, errors.New("chat backend " + backend + " is not available") } session, err := adapter.Create(ctx, title, directory) if err != nil { return protocol.ChatSession{}, err } session.Backend = backend m.mu.Lock() m.cache[session.ID] = backend m.mu.Unlock() return session, nil } func (m *chatManager) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) { return m.CreateBackend(ctx, title, directory, "opencode") } func (m *chatManager) Prompt(ctx context.Context, sessionID, text string) error { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return err } return adapter.Prompt(ctx, sessionID, text) } func (m *chatManager) PromptWithMessageID(ctx context.Context, sessionID, text, messageID string) error { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return err } if withID, ok := adapter.(chatPromptWithMessageID); ok { return withID.PromptWithMessageID(ctx, sessionID, text, messageID) } return adapter.Prompt(ctx, sessionID, text) } func (m *chatManager) Stream(ctx context.Context, sessionID string, ready func(), emit func(protocol.ChatEventFrame) error) error { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return err } return adapter.Stream(ctx, sessionID, ready, emit) } func (m *chatManager) Interrupt(ctx context.Context, sessionID string) error { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return err } return adapter.Interrupt(ctx, sessionID) } func (m *chatManager) Messages(ctx context.Context, sessionID string, limit int, cursor string) (protocol.ChatHistoryPage, error) { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return protocol.ChatHistoryPage{}, err } return adapter.Messages(ctx, sessionID, limit, cursor) } func (m *chatManager) Sessions(ctx context.Context) ([]protocol.ChatSession, error) { sessions := []protocol.ChatSession{} seen := map[string]bool{} for _, adapter := range []chatBroker{m.opencode, m.codex} { if adapter == nil { continue } list, err := adapter.Sessions(ctx) if err != nil { continue } for _, session := range list { if session.ID == "" || seen[session.ID] { continue } seen[session.ID] = true sessions = append(sessions, session) } } // A backend that cannot enumerate its own store still has registry rows. // Resolve those individually so an older/restarted backend never silently // drops a chat from the list. if m.registry != nil { if rows, err := m.registry.OperatorSessions(ctx); err == nil { for _, row := range rows { if seen[row.ID] || row.Backend == "" || row.Backend == "opencode" { continue } adapter := m.adapter(row.Backend) if adapter == nil { continue } if session, found, err := adapter.Session(ctx, row.ID); err == nil && found { seen[row.ID] = true sessions = append(sessions, session) } } } } return sessions, nil } func (m *chatManager) Session(ctx context.Context, sessionID string) (protocol.ChatSession, bool, error) { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return protocol.ChatSession{}, false, err } return adapter.Session(ctx, sessionID) } func (m *chatManager) Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return nil, err } if permissions, ok := adapter.(interface { Permissions(context.Context, string) ([]protocol.ChatPermissionFrame, error) }); ok { return permissions.Permissions(ctx, sessionID) } return nil, nil } func (m *chatManager) Shells(ctx context.Context, sessionID string) ([]protocol.ChatShell, error) { adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return nil, err } if shells, ok := adapter.(interface { Shells(context.Context, string) ([]protocol.ChatShell, error) }); ok { return shells.Shells(ctx, sessionID) } return nil, nil } func (m *chatManager) Reply(ctx context.Context, request protocol.ChatReplyRequest) error { adapter, err := m.brokerFor(ctx, request.SessionID) if err != nil { return err } return adapter.Reply(ctx, request) } func (m *chatManager) ActivateSkill(ctx context.Context, sessionID, skill string) error { // Skill bootstrap is an OpenCode chat concept. Other harnesses return from // create without a manager skill and must not fail the create. if m.backendFor(ctx, sessionID) != "opencode" { return nil } adapter, err := m.brokerFor(ctx, sessionID) if err != nil { return err } return adapter.ActivateSkill(ctx, sessionID, skill) } func (m *chatManager) Answer(ctx context.Context, request protocol.ChatAnswerRequest) error { adapter, err := m.brokerFor(ctx, request.SessionID) if err != nil { return err } answerer, ok := adapter.(chatAnswerer) if !ok { return errors.New("this chat backend cannot answer questions") } return answerer.Answer(ctx, request) } func (m *chatManager) ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, error) { adapter, err := m.brokerFor(ctx, query.SessionID) if err != nil { return protocol.ChatShellOutputPage{}, err } reader, ok := adapter.(chatShellOutputReader) if !ok { return protocol.ChatShellOutputPage{}, errors.New("this chat backend has no shell output") } return reader.ShellOutput(ctx, query) } func (m *chatManager) ReleaseShells(sessionID string) { m.mu.Lock() backend := m.cache[sessionID] m.mu.Unlock() adapter := m.adapter(backend) if releaser, ok := adapter.(chatShellReleaser); ok { releaser.ReleaseShells(sessionID) } }