package webui import ( "context" "encoding/json" "fmt" "net/http" "reflect" "strings" "sync" "github.com/google/uuid" "github.com/samcharles93/archie-core/internal/gateway" "github.com/samcharles93/archie-core/internal/releaseupdate" ) // ChatService is the shared conversational surface exposed to the dashboard. // It deliberately contains the gateway Router rather than duplicating command // dispatch in the HTTP layer. type ChatService struct { Router *gateway.Router Sessions gateway.SessionStore Turns *gateway.Turns Models gateway.ModelManager Personas *gateway.PersonaRegistry Updates ChatUpdateService Dangerous *DangerousService updateMu sync.Mutex updateInProgress bool } // ChatUpdateService is the shared release workflow used by chat gateways. // The web adapter uses recipient zero for the locally authenticated operator. type ChatUpdateService interface { Check(context.Context, int64) (releaseupdate.Snapshot, error) Defer(context.Context, int64, releaseupdate.Snapshot) error Install(context.Context, releaseupdate.InstallMeta, func(string)) (releaseupdate.Result, error) CanInstall() bool } type chatMessageRequest struct { ChannelID string `json:"channel_id"` SourceID string `json:"source_id"` Text string `json:"text"` } type chatPersonaRequest struct { SessionID string `json:"session_id"` Name string `json:"name"` } type chatCancelRequest struct { SessionID string `json:"session_id"` } type chatUpdateRequest struct { Snapshot releaseupdate.Snapshot `json:"snapshot"` } type dangerousRequest struct { Spec string `json:"spec"` } type dangerousDecisionRequest struct { Decision string `json:"decision"` } func (s *Server) chatReady(w http.ResponseWriter) (*ChatService, bool) { if s.Chat == nil || s.Chat.Router == nil || s.Chat.Sessions == nil { http.Error(w, "chat is not configured", http.StatusNotImplemented) return nil, false } if !chatUpdateServiceConfigured(s.Chat.Router.Updates) && chatUpdateServiceConfigured(s.Chat.Updates) { s.Chat.Router.Updates = s.Chat.Updates } if s.Chat.Router.Dangerous == nil && s.Chat.Dangerous != nil { s.Chat.Router.Dangerous = s.Chat.Dangerous } return s.Chat, true } func chatUpdateServiceConfigured(updates ChatUpdateService) bool { if updates == nil { return false } value := reflect.ValueOf(updates) switch value.Kind() { case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice: return !value.IsNil() default: return true } } func (s *Server) handleChatSessions(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } sessions, err := chat.Sessions.List(r.Context()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } out := make([]gateway.SessionContext, 0, len(sessions)) for _, session := range sessions { if session.Source.Platform == "web" { out = append(out, session) } } writeJSON(w, map[string]any{ "sessions": out, "models": modelNames(chat.Models), "models_by_provider": modelsByProvider(chat.Models), "providers": modelProviders(chat.Models), "active_model": activeModel(chat.Models), "active_provider": activeProvider(chat.Models), "personas": personaNames(chat.Personas), "active_personas": activePersonas(chat.Personas, out), "commands": chatCommandSpecs(chat), "restart_available": chat.Router.Restart != nil, "dangerous_available": chat.Dangerous != nil, }) } func chatCommandSpecs(chat *ChatService) []gateway.CommandSpec { specs := gateway.LocalCommandSpecs() if chat.Dangerous != nil { specs = append( specs, gateway.CommandSpec{Command: "/rollback", Description: "Request approval to restore a filesystem checkpoint", Usage: "/rollback [number]"}, gateway.CommandSpec{Command: "/stop", Description: "Request approval to terminate a background process", Usage: "/stop "}, gateway.CommandSpec{Command: "/deny", Description: "Deny a pending dangerous action", Usage: "/deny "}, ) } return specs } func (s *Server) handleChatMessages(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } sessionID := r.PathValue("id") session, err := chat.Sessions.Get(r.Context(), sessionID) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } if session == nil || session.Source.Platform != "web" { http.Error(w, "session not found", http.StatusNotFound) return } messages, err := chat.Sessions.RecentMessages(r.Context(), sessionID, 200) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } writeJSON(w, messages) } func (s *Server) decodeChatMessage(w http.ResponseWriter, r *http.Request) (gateway.Message, bool) { var req chatMessageRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, "invalid chat message", http.StatusBadRequest) return gateway.Message{}, false } req.Text = strings.TrimSpace(req.Text) if req.Text == "" || req.ChannelID == "" { http.Error(w, "text and channel_id are required", http.StatusBadRequest) return gateway.Message{}, false } if req.SourceID == "" { req.SourceID = newChatSourceID() } return gateway.Message{ SourceID: req.SourceID, ChannelID: req.ChannelID, ThreadID: "", From: "web", Text: req.Text, }, true } func (s *Server) handleChatMessage(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } msg, ok := s.decodeChatMessage(w, r) if !ok { return } reply, err := chat.Router.Route(r.Context(), msg) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } sessionID, err := chat.Router.ResolveSessionKey(r.Context(), msg) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } writeJSON(w, map[string]string{"reply": reply, "session_id": sessionID}) } // chatStreamEvent is one `data: {...}` frame of the chat stream. A tool frame // names the tool in Tool, carries its one-line outcome in Text, and signals // failure through Failed -- a structured field, so the browser styles the // two apart by reading it rather than by sniffing a "failed:" prefix out of // Text, which a successful tool's own output can start with too. // // Text is always emitted, empty or not: the browser concatenates it and // assigns it, so a missing key would put the string "undefined" into the // transcript on a turn whose reply is empty. type chatStreamEvent struct { Type string `json:"type"` Text string `json:"text"` Tool string `json:"tool,omitempty"` ToolCallID string `json:"tool_call_id,omitempty"` Parameters string `json:"parameters,omitempty"` Failed bool `json:"failed,omitempty"` SessionID string `json:"session_id,omitempty"` } // chatStreamSink adapts the stream writer to gateway.TurnStream so text and // tool activity reach the browser through one ordered path. // // showToolCalls gates ToolCall the same way Telegram's liveReply gates its // own tool narration: config.ChatConfig.ShowToolCalls is one setting for // every chat channel, so an operator who turned it off gets no tool frames // on the dashboard either, not just in Telegram. It is snapshotted into the // sink at stream start rather than read live, for the same reason Telegram // snapshots it per-reply -- a config reload mid-turn must not change what a // turn already in flight narrates. type chatStreamSink struct { write func(chatStreamEvent) showToolCalls bool } func (s chatStreamSink) Delta(text string) { s.write(chatStreamEvent{Type: "delta", Text: text}) } func (s chatStreamSink) ToolCall(event gateway.ToolCallEvent) { if !s.showToolCalls || event.Name == "" { return } s.write(chatStreamEvent{ Type: "tool", Tool: event.Name, ToolCallID: event.ID, Parameters: event.Parameters, Text: event.Summary(), Failed: event.Err != "", }) } // chatShowToolCalls reports config.ChatConfig.ShowToolCalls, the one setting // shared by every chat channel. Off (the default) when Cfg is nil, matching // the field's own off-by-default doc comment: a dashboard embedded without // live config must not narrate tool activity nobody opted into. func (s *Server) chatShowToolCalls() bool { if s.Cfg == nil { return false } return s.Cfg.Get().Chat.ShowToolCalls } func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } msg, ok := s.decodeChatMessage(w, r) if !ok { return } flusher, ok := w.(http.Flusher) if !ok { http.Error(w, "streaming unsupported", http.StatusInternalServerError) return } w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Cache-Control", "no-cache") w.Header().Set("X-Accel-Buffering", "no") writeChatEvent := func(event chatStreamEvent, sessionID string) { event.SessionID = sessionID payload, _ := json.Marshal(event) _, _ = fmt.Fprintf(w, "data: %s\n\n", payload) flusher.Flush() } sessionID, err := chat.Router.ResolveSessionKey(r.Context(), msg) if err != nil { writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, "") return } writeChatEvent(chatStreamEvent{Type: "started"}, sessionID) showToolCalls := s.chatShowToolCalls() var reply string if chat.Turns == nil { reply, err = chat.Router.RouteStream(r.Context(), msg, chatStreamSink{ showToolCalls: showToolCalls, write: func(event chatStreamEvent) { writeChatEvent(event, sessionID) }, }) } else { type turnResult struct { reply string err error } // One channel carries both text and tool events, because the // order between them is the point: a tool line that overtakes // the sentence it interrupted describes a turn that never // happened. events := make(chan chatStreamEvent, 32) result := make(chan turnResult, 1) chat.Turns.Submit(r.Context(), sessionID, func(turnCtx context.Context) { turnReply, turnErr := chat.Router.RouteStream(turnCtx, msg, chatStreamSink{ showToolCalls: showToolCalls, write: func(event chatStreamEvent) { select { case events <- event: case <-r.Context().Done(): } }, }) result <- turnResult{reply: turnReply, err: turnErr} }) for { select { case event := <-events: writeChatEvent(event, sessionID) case turn := <-result: for { select { case event := <-events: writeChatEvent(event, sessionID) default: goto drained } } drained: reply, err = turn.reply, turn.err goto turnDone case <-r.Context().Done(): chat.Turns.Stop(sessionID) return } } turnDone: } if err != nil { writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, sessionID) return } if resolved, resolveErr := chat.Router.ResolveSessionKey(r.Context(), msg); resolveErr == nil { sessionID = resolved } writeChatEvent(chatStreamEvent{Type: "done", Text: reply}, sessionID) } func (s *Server) handleChatCancel(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if chat.Turns == nil { http.Error(w, "chat cancellation is not configured", http.StatusNotImplemented) return } var req chatCancelRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SessionID == "" { http.Error(w, "session_id is required", http.StatusBadRequest) return } session, err := chat.Sessions.Get(r.Context(), req.SessionID) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } if session == nil || session.Source.Platform != "web" { http.Error(w, "session not found", http.StatusNotFound) return } cancelled, dropped := chat.Turns.Stop(req.SessionID) writeJSON(w, map[string]any{"cancelled": cancelled, "dropped": dropped}) } func (s *Server) handleChatPersona(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if chat.Personas == nil { http.Error(w, "personality switching is not configured", http.StatusNotImplemented) return } var req chatPersonaRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SessionID == "" || req.Name == "" { http.Error(w, "session_id and name are required", http.StatusBadRequest) return } if session, err := chat.Sessions.Get(r.Context(), req.SessionID); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } else if session == nil || session.Source.Platform != "web" { http.Error(w, "session not found", http.StatusNotFound) return } if !chat.Personas.SetActive(req.SessionID, strings.ToLower(req.Name)) { http.Error(w, fmt.Sprintf("unknown personality %q", req.Name), http.StatusBadRequest) return } writeJSON(w, map[string]any{"ok": true, "name": strings.ToLower(req.Name)}) } func (s *Server) handleChatUpdate(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if !chatUpdateServiceConfigured(chat.Updates) { http.Error(w, "updates are not configured", http.StatusNotImplemented) return } snapshot, err := chat.Updates.Check(r.Context(), 0) if err != nil { http.Error(w, err.Error(), http.StatusBadGateway) return } writeJSON(w, map[string]any{ "snapshot": snapshot, "available": snapshot.Available(), "can_install": chat.Updates.CanInstall(), }) } func (s *Server) handleChatUpdateDefer(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if !chatUpdateServiceConfigured(chat.Updates) { http.Error(w, "updates are not configured", http.StatusNotImplemented) return } var req chatUpdateRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, "invalid update snapshot", http.StatusBadRequest) return } if err := chat.Updates.Defer(r.Context(), 0, req.Snapshot); err != nil { http.Error(w, err.Error(), http.StatusConflict) return } writeJSON(w, map[string]bool{"ok": true}) } func (s *Server) handleChatUpdateInstall(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if !chatUpdateServiceConfigured(chat.Updates) || !chat.Updates.CanInstall() { http.Error(w, "update installation is not configured", http.StatusNotImplemented) return } var req chatUpdateRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil || len(req.Snapshot.Available()) == 0 { http.Error(w, "the displayed update snapshot is required", http.StatusBadRequest) return } fresh, err := chat.Updates.Check(r.Context(), 0) if err != nil { http.Error(w, err.Error(), http.StatusBadGateway) return } if !releaseupdate.SameAvailable(fresh, req.Snapshot) { http.Error(w, "available releases changed; check again", http.StatusConflict) return } chat.updateMu.Lock() if chat.updateInProgress { chat.updateMu.Unlock() http.Error(w, "an update is already in progress", http.StatusConflict) return } chat.updateInProgress = true chat.updateMu.Unlock() defer func() { chat.updateMu.Lock() chat.updateInProgress = false chat.updateMu.Unlock() }() progress := make([]string, 0, 4) result, err := chat.Updates.Install(r.Context(), releaseupdate.InstallMeta{Channel: "webui"}, func(message string) { progress = append(progress, message) }) if err != nil { http.Error(w, err.Error(), http.StatusBadGateway) return } writeJSON(w, map[string]any{"ok": true, "progress": progress, "result": result}) } func (s *Server) handleChatDangerousState(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if chat.Dangerous == nil { http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented) return } checkpoints, err := chat.Dangerous.Checkpoints(r.Context()) if err != nil { http.Error(w, err.Error(), http.StatusBadGateway) return } writeJSON(w, map[string]any{"checkpoints": checkpoints, "pending": chat.Dangerous.Pending()}) } func (s *Server) handleChatDangerousRequest(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if chat.Dangerous == nil { http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented) return } var req dangerousRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.Spec) == "" { http.Error(w, "spec is required", http.StatusBadRequest) return } action, result, executed, err := chat.Dangerous.Request(r.Context(), r.PathValue("kind"), req.Spec) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } writeJSON(w, map[string]any{"action": action, "result": result, "executed": executed}) } func (s *Server) handleChatDangerousDecision(w http.ResponseWriter, r *http.Request) { chat, ok := s.chatReady(w) if !ok { return } if chat.Dangerous == nil { http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented) return } var req dangerousDecisionRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.Decision) == "" { http.Error(w, "decision is required", http.StatusBadRequest) return } result, err := chat.Dangerous.Decide(r.Context(), r.PathValue("id"), req.Decision) if err != nil { http.Error(w, err.Error(), http.StatusConflict) return } writeJSON(w, map[string]any{"ok": true, "result": result}) } func modelNames(models gateway.ModelManager) []string { if models == nil { return []string{} } return models.Models() } func activeModel(models gateway.ModelManager) string { if models == nil { return "" } return models.ActiveModel() } func activeProvider(models gateway.ModelManager) string { manager, ok := models.(gateway.ProviderModelManager) if !ok { return "" } return manager.ActiveProvider() } func modelProviders(models gateway.ModelManager) []string { manager, ok := models.(gateway.ProviderModelManager) if !ok { return []string{} } return manager.Providers() } func modelsByProvider(models gateway.ModelManager) map[string][]string { if models == nil { return map[string][]string{} } if manager, ok := models.(gateway.ProviderModelManager); ok { groups := make(map[string][]string, len(manager.Providers())) for _, provider := range manager.Providers() { groups[provider] = manager.ModelsForProvider(provider) } return groups } groups := make(map[string][]string) for _, model := range models.Models() { provider, _, ok := strings.Cut(model, "/") if !ok { provider = "" } groups[provider] = append(groups[provider], model) } return groups } func activePersonas(personas *gateway.PersonaRegistry, sessions []gateway.SessionContext) map[string]string { active := make(map[string]string, len(sessions)) if personas == nil { return active } for _, session := range sessions { active[session.SessionID] = personas.ActiveName(session.SessionID) } return active } func personaNames(personas *gateway.PersonaRegistry) []string { if personas == nil { return []string{} } return personas.List() } func newChatSourceID() string { return "web-" + uuid.NewString() }