The check compares two declarations; it never reads the bytes, so it cannot tell whether a file is what its content type says. The comment and the test row claiming otherwise have gone, and so has an allowance letting a video carry an image type, which no producer emits. A caller that named the attachment type itself -- a browser upload -- must now also state a content type, since the previous empty-type escape made the check optional there. The Telegram declared-size rule is deleted: the shared check runs first with the same ceiling, so only the rule on the bytes actually received can still fire.
616 lines
19 KiB
Go
616 lines
19 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/lifecycle"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/releaseupdate"
|
|
)
|
|
|
|
// ChatService is the shared conversational surface exposed to the dashboard.
|
|
// Handlers depend on the Gateway-owned contract and never retain Gateway
|
|
// implementation objects.
|
|
type ChatService struct {
|
|
Contract messaging.ChatContract
|
|
Updates ChatUpdateService
|
|
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.Snapshot, 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"`
|
|
// Page is the dashboard route the operator is on (e.g. "/tasks"). It is
|
|
// set by the web chat so the agent's system prompt can state where the
|
|
// operator is looking and point them somewhere relevant.
|
|
Page string `json:"page,omitempty"`
|
|
// Voice is a recorded clip, transcribed by the Gateway like a Telegram
|
|
// voice note. Base64 in JSON.
|
|
Voice *chatVoice `json:"voice,omitempty"`
|
|
}
|
|
|
|
type chatVoice struct {
|
|
Data []byte `json:"data"`
|
|
MIMEType string `json:"mime_type"`
|
|
}
|
|
|
|
// maxVoiceBytes bounds a recorded clip: about ten minutes of Opus.
|
|
const maxVoiceBytes = 10 << 20
|
|
|
|
// chatMessageView is one entry of a session's history as the dashboard
|
|
// reads it. The persisted record is messaging.Message; this is the shape
|
|
// the browser has always been served, kept here so the HTTP response owns
|
|
// its own field names rather than exposing a domain struct's.
|
|
type chatMessageView struct {
|
|
MessageID string
|
|
SourceID string
|
|
From string
|
|
Text string
|
|
At time.Time
|
|
// Tagged, alone among these fields: a transcript written before
|
|
// attachments persisted must keep the payload it has always had, so a
|
|
// message with no media omits the key rather than serving null.
|
|
Media []chatMediaView `json:"media,omitempty"`
|
|
}
|
|
|
|
// chatMediaView is a stored message attachment as the dashboard reads it.
|
|
type chatMediaView struct {
|
|
Type string `json:"type"`
|
|
FileName string `json:"file_name,omitempty"`
|
|
MIMEType string `json:"mime_type,omitempty"`
|
|
FileSize *int64 `json:"file_size,omitempty"`
|
|
Width *int `json:"width,omitempty"`
|
|
Height *int `json:"height,omitempty"`
|
|
Duration *int `json:"duration,omitempty"`
|
|
URL string `json:"url,omitempty"`
|
|
}
|
|
|
|
// chatMediaViews maps a message's stored attachments onto the transcript
|
|
// view, keeping the descriptive fields a reader needs to know a file was
|
|
// there.
|
|
func chatMediaViews(media []messaging.MediaAttachment) []chatMediaView {
|
|
if len(media) == 0 {
|
|
return nil
|
|
}
|
|
views := make([]chatMediaView, 0, len(media))
|
|
for _, attachment := range media {
|
|
views = append(views, chatMediaView{
|
|
Type: attachment.Type,
|
|
FileName: attachment.FileName,
|
|
MIMEType: attachment.MIMEType,
|
|
FileSize: attachment.FileSize,
|
|
Width: attachment.Width,
|
|
Height: attachment.Height,
|
|
Duration: attachment.Duration,
|
|
URL: attachment.URL,
|
|
})
|
|
}
|
|
return views
|
|
}
|
|
|
|
type chatCancelRequest struct {
|
|
SessionID string `json:"session_id"`
|
|
}
|
|
|
|
type chatUpdateRequest struct {
|
|
Snapshot releaseupdate.Snapshot `json:"snapshot"`
|
|
}
|
|
|
|
type chatTurnView struct {
|
|
TurnID string `json:"turn_id"`
|
|
AssistantMessageID string `json:"assistant_message_id,omitempty"`
|
|
Status messaging.TurnStatus `json:"status"`
|
|
Error string `json:"error,omitempty"`
|
|
ToolCalls []chatToolView `json:"tool_calls,omitempty"`
|
|
}
|
|
|
|
type chatToolView struct {
|
|
ID string `json:"id,omitempty"`
|
|
Name string `json:"name"`
|
|
Parameters string `json:"parameters,omitempty"`
|
|
Summary string `json:"summary"`
|
|
Failed bool `json:"failed"`
|
|
DurationMS int64 `json:"duration_ms,omitempty"`
|
|
TextOffset int `json:"text_offset,omitempty"`
|
|
}
|
|
|
|
func (s *Server) chatReady(w http.ResponseWriter) (*ChatService, bool) {
|
|
if s.Chat == nil || s.Chat.Contract == nil {
|
|
http.Error(w, "chat is not configured", http.StatusNotImplemented)
|
|
return nil, false
|
|
}
|
|
return s.Chat, true
|
|
}
|
|
|
|
func chatUpdateServiceConfigured(updates ChatUpdateService) bool {
|
|
return !lifecycle.IsNil(updates)
|
|
}
|
|
|
|
func (s *Server) handleChatSessions(w http.ResponseWriter, r *http.Request) {
|
|
chat, ok := s.chatReady(w)
|
|
if !ok {
|
|
return
|
|
}
|
|
snapshot, err := chat.Contract.Snapshot(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
out := make([]messaging.SessionContext, 0, len(snapshot.Sessions))
|
|
for _, session := range snapshot.Sessions {
|
|
if s.ownsChatSession(r.Context(), session) {
|
|
out = append(out, session)
|
|
}
|
|
}
|
|
writeJSON(w, map[string]any{
|
|
"sessions": out,
|
|
"models": snapshot.Models,
|
|
"models_by_provider": snapshot.ModelsByProvider,
|
|
"providers": snapshot.Providers,
|
|
"active_model": snapshot.ActiveModel,
|
|
"active_provider": snapshot.ActiveProvider,
|
|
"voice_available": snapshot.VoiceAvailable,
|
|
"commands": chatCommandSpecs(chat),
|
|
})
|
|
}
|
|
|
|
func chatCommandSpecs(chat *ChatService) []messaging.CommandSpec {
|
|
specs := messaging.LocalCommandSpecs()
|
|
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, found, err := chat.Contract.GetSession(r.Context(), sessionID)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if !found || !s.ownsChatSession(r.Context(), session) {
|
|
http.Error(w, "session not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
messages, err := chat.Contract.RecentMessages(r.Context(), sessionID, 200)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
views := make([]chatMessageView, 0, len(messages))
|
|
for _, message := range messages {
|
|
views = append(views, chatMessageView{
|
|
MessageID: string(message.ID), SourceID: message.SourceID,
|
|
From: message.Sender, Text: message.Text, At: message.At,
|
|
Media: chatMediaViews(message.Media),
|
|
})
|
|
}
|
|
writeJSON(w, views)
|
|
}
|
|
|
|
func (s *Server) handleChatTurns(w http.ResponseWriter, r *http.Request) {
|
|
chat, ok := s.chatReady(w)
|
|
if !ok {
|
|
return
|
|
}
|
|
sessionID := r.PathValue("id")
|
|
session, found, err := chat.Contract.GetSession(r.Context(), sessionID)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if !found || !s.ownsChatSession(r.Context(), session) {
|
|
http.Error(w, "session not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
turns, err := chat.Contract.RecentTurns(r.Context(), sessionID, 200)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
views := make([]chatTurnView, 0, len(turns))
|
|
for _, turn := range turns {
|
|
view := chatTurnView{
|
|
TurnID: turn.TurnID, AssistantMessageID: turn.AssistantMessageID,
|
|
Status: turn.Status, Error: turn.Error,
|
|
ToolCalls: make([]chatToolView, 0, len(turn.ToolCalls)),
|
|
}
|
|
for _, tool := range turn.ToolCalls {
|
|
view.ToolCalls = append(view.ToolCalls, chatToolView{
|
|
ID: tool.ID, Name: tool.Name, Parameters: tool.Parameters,
|
|
Summary: tool.Summary(), Failed: tool.Err != "", DurationMS: tool.DurationMS, TextOffset: tool.TextOffset,
|
|
})
|
|
}
|
|
views = append(views, view)
|
|
}
|
|
writeJSON(w, views)
|
|
}
|
|
|
|
func (s *Server) decodeChatMessage(w http.ResponseWriter, r *http.Request) (messaging.Inbound, bool) {
|
|
var req chatMessageRequest
|
|
// Base64 makes a clip a third larger than its bytes.
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxVoiceBytes*3/2)).Decode(&req); err != nil {
|
|
http.Error(w, "invalid chat message", http.StatusBadRequest)
|
|
return messaging.Inbound{}, false
|
|
}
|
|
req.Text = strings.TrimSpace(req.Text)
|
|
var media []messaging.MediaAttachment
|
|
if req.Voice != nil {
|
|
if len(req.Voice.Data) == 0 || len(req.Voice.Data) > maxVoiceBytes {
|
|
http.Error(w, "voice clip is empty or too long", http.StatusBadRequest)
|
|
return messaging.Inbound{}, false
|
|
}
|
|
media = append(media, messaging.MediaAttachment{Type: messaging.MediaTypeVoice, MIMEType: req.Voice.MIMEType, Data: req.Voice.Data})
|
|
if err := messaging.ValidateAuthoredInbound(media[0]); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return messaging.Inbound{}, false
|
|
}
|
|
if req.Text == "" {
|
|
req.Text = "[voice message]"
|
|
}
|
|
}
|
|
if req.Text == "" || req.ChannelID == "" {
|
|
http.Error(w, "text and channel_id are required", http.StatusBadRequest)
|
|
return messaging.Inbound{}, false
|
|
}
|
|
if req.SourceID == "" {
|
|
req.SourceID = newChatSourceID()
|
|
}
|
|
// The browser has no threading, so the conversation is the channel
|
|
// alone. Page is the route the operator is looking at, and stays out
|
|
// of the record.
|
|
return messaging.Inbound{
|
|
Message: messaging.Message{
|
|
SourceID: req.SourceID,
|
|
ConversationID: messaging.ConversationID{ChannelID: req.ChannelID, ThreadID: chatUser(r.Context())},
|
|
SenderID: chatUser(r.Context()),
|
|
Sender: "web",
|
|
Role: messaging.RoleUser,
|
|
Text: req.Text,
|
|
},
|
|
Media: media,
|
|
Page: req.Page,
|
|
// The dashboard names the channel it carries; see the platform field's
|
|
// note in internal/domain/messaging/inbound.go.
|
|
Platform: "web",
|
|
}, 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.Contract.Route(r.Context(), msg)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, map[string]string{"reply": reply.Text, "session_id": reply.SessionID})
|
|
}
|
|
|
|
// chatStreamEvent is one frame of the chat stream. Text is always emitted.
|
|
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"`
|
|
DurationMS int64 `json:"duration_ms,omitempty"`
|
|
TextOffset int `json:"text_offset,omitempty"`
|
|
SessionID string `json:"session_id,omitempty"`
|
|
// Path and Label carry a dashboard_navigate result so the browser can
|
|
// render a clickable chip that routes the operator to the page. Present
|
|
// only on a navigate event.
|
|
Path string `json:"path,omitempty"`
|
|
Label string `json:"label,omitempty"`
|
|
// Ask is a question the turn waits on; answered by POST /api/chat/answer.
|
|
Ask *chatAsk `json:"ask,omitempty"`
|
|
}
|
|
|
|
// chatStreamSink writes turn text and tool activity to the browser stream.
|
|
// showToolCalls is fixed for the stream.
|
|
type chatStreamSink struct {
|
|
write func(chatStreamEvent)
|
|
showToolCalls bool
|
|
// files hands out downloads for the local files a turn sends.
|
|
files *chatFiles
|
|
owner string
|
|
}
|
|
|
|
func (s chatStreamSink) ToolCall(event messaging.ToolCallEvent) {
|
|
// A dashboard_navigate call is an explicit point-the-operator-there
|
|
// result, not tool narration, so it renders a clickable chip even when
|
|
// ShowToolCalls is off. Parse the resolved path/label from the tool's
|
|
// JSON result and emit a dedicated navigate frame.
|
|
if event.Name == "dashboard_navigate" && event.Err == "" {
|
|
var result messaging.DashboardNavigateResult
|
|
if err := json.Unmarshal([]byte(event.Output), &result); err == nil && result.Path != "" {
|
|
s.write(chatStreamEvent{
|
|
Type: "navigate",
|
|
Tool: event.Name,
|
|
ToolCallID: event.ID,
|
|
Path: result.Path,
|
|
Label: result.Label,
|
|
})
|
|
return
|
|
}
|
|
}
|
|
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 != "",
|
|
DurationMS: event.DurationMS,
|
|
TextOffset: event.TextOffset,
|
|
})
|
|
}
|
|
|
|
// Media is sent as a link in the text stream; a local file is reported as
|
|
// undelivered.
|
|
func (s chatStreamSink) Media(event messaging.MediaEvent) {
|
|
att := event.Attachment
|
|
switch {
|
|
case att.URL != "":
|
|
s.write(chatStreamEvent{Type: "delta", Text: "\n\n📎 " + att.Type + ": " + att.URL})
|
|
case att.Path != "" && s.files != nil:
|
|
name := att.FileName
|
|
if name == "" {
|
|
name = filepath.Base(att.Path)
|
|
}
|
|
s.write(chatStreamEvent{Type: "delta", Text: "\n\n📎 [" + name + "](" + chatFileURL(s.files.offerFor(att.Path, att.FileName, s.owner)) + ")"})
|
|
}
|
|
}
|
|
|
|
// chatShowToolCalls reports config.ChatConfig.ShowToolCalls, false when no
|
|
// config is available.
|
|
func (s *Server) chatShowToolCalls(ctx context.Context) bool {
|
|
view, found, err := s.configSource()(ctx)
|
|
if err != nil || !found {
|
|
return false
|
|
}
|
|
return view.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")
|
|
// An ask is written from the gateway client's goroutine while this one
|
|
// writes the turn's events.
|
|
var writeMu sync.Mutex
|
|
writeChatEvent := func(event chatStreamEvent, sessionID string) {
|
|
writeMu.Lock()
|
|
defer writeMu.Unlock()
|
|
event.SessionID = sessionID
|
|
payload, _ := json.Marshal(event)
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", payload)
|
|
flusher.Flush()
|
|
}
|
|
asker := dashboardAsker{asks: &s.chatAsks, write: func(frame chatStreamEvent) { writeChatEvent(frame, "") }}
|
|
events, err := chat.Contract.Stream(withDashboardAsks(r.Context(), asker), msg)
|
|
if err != nil {
|
|
writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, "")
|
|
return
|
|
}
|
|
sink := chatStreamSink{showToolCalls: s.chatShowToolCalls(r.Context()), files: &s.chatFiles, owner: chatUser(r.Context())}
|
|
for event := range events {
|
|
sink.write = func(frame chatStreamEvent) { writeChatEvent(frame, event.SessionID) }
|
|
switch event.Kind {
|
|
case "tool":
|
|
sink.ToolCall(event.Tool)
|
|
case "media":
|
|
sink.Media(event.Media)
|
|
default:
|
|
writeChatEvent(chatStreamEvent{Type: event.Kind, Text: event.Text}, event.SessionID)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) handleChatCancel(w http.ResponseWriter, r *http.Request) {
|
|
chat, ok := s.chatReady(w)
|
|
if !ok {
|
|
return
|
|
}
|
|
snapshot, err := chat.Contract.Snapshot(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if !snapshot.CancellationAvailable {
|
|
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, found, err := chat.Contract.GetSession(r.Context(), req.SessionID)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if !found || !s.ownsChatSession(r.Context(), session) {
|
|
http.Error(w, "session not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
result, err := chat.Contract.Cancel(r.Context(), req.SessionID)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"cancelled": result.Cancelled, "dropped": result.Dropped})
|
|
}
|
|
|
|
// writeUpdateCheckError answers an unset check command as not configured, which
|
|
// the dashboard shows as such rather than as a failure.
|
|
func writeUpdateCheckError(w http.ResponseWriter, err error) {
|
|
if errors.Is(err, releaseupdate.ErrNotConfigured) {
|
|
http.Error(w, "updates are not configured", http.StatusNotImplemented)
|
|
return
|
|
}
|
|
http.Error(w, err.Error(), http.StatusBadGateway)
|
|
}
|
|
|
|
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 {
|
|
writeUpdateCheckError(w, err)
|
|
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 {
|
|
writeUpdateCheckError(w, err)
|
|
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)
|
|
meta := releaseupdate.InstallMeta{Channel: "webui", ReportPath: s.UpdateReportPath}
|
|
if s.TelegramUpdateReportPath != "" && s.TelegramUpdateChatID != 0 {
|
|
meta.Channel = "telegram"
|
|
meta.ChatID = s.TelegramUpdateChatID
|
|
meta.ReportPath = s.TelegramUpdateReportPath
|
|
}
|
|
result, err := chat.Updates.Install(r.Context(), fresh, meta, 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 newChatSourceID() string {
|
|
id, err := uuid.NewV7()
|
|
if err != nil {
|
|
return "web-" + uuid.NewString()
|
|
}
|
|
return "web-" + id.String()
|
|
}
|
|
|
|
// The server supplies the person thread; browser-supplied conversation IDs
|
|
// cannot select another person's history.
|
|
func chatUser(ctx context.Context) string {
|
|
if value, ok := ActingIdentity(ctx); ok {
|
|
return string(value.ID)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (s *Server) ownsChatSession(ctx context.Context, session messaging.SessionContext) bool {
|
|
return session.Source.Platform == "web" && session.Source.ThreadID == chatUser(ctx)
|
|
}
|