Files
archie/internal/webui/api_chat.go
T
sam ddd532b824 feat(update): stream live progress and roll back failed updates automatically
The /update command went silent between "starting" and one final message,
gave no version summary, and required manual intervention on failure.

CommandInstaller now streams the installer script's stdout live instead of
buffering it, and parses a structured result (previous/installed versions,
per-component status) from a sentinel line. Because the reference install
script hands the daemon restart off to a detached systemd unit specifically
so restarting archied.service doesn't kill the process that requested the
update, the outcome is reported in two phases: the synchronous build/install
result comes back through Install() itself, and the post-restart health
check/rollback outcome is written by a new watchdog script and relayed by
whichever archied process boots next, via a small JSON handoff file cleared
once relayed.

Also fixes three defects an adversarial review pass found in the first
draft: the caller's request/handler context was passed straight into the
install child process, so a concurrent /restart or a browser disconnect
could SIGKILL it mid binary-copy; Telegram and the web dashboard each
tracked "install in progress" with their own private flag despite sharing
one Service, allowing two installs to race the same .prev backups; and the
watchdog reported rolled_back:true even when no backup existed to restore,
which would have told an operator to stand down while the daemon was still
broken.

internal/webui gains an unauthenticated /healthz the watchdog polls after
restarting archied.
2026-08-19 01:47:29 +10:00

639 lines
19 KiB
Go

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 <process-name>"},
gateway.CommandSpec{Command: "/deny", Description: "Deny a pending dangerous action", Usage: "/deny <action-id>"},
)
}
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()
}