274 lines
8.8 KiB
Go
274 lines
8.8 KiB
Go
package web
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"github.com/a-h/templ"
|
|
|
|
"git.d-ma.be/mathias/tapir/internal/adapters/chat"
|
|
"git.d-ma.be/mathias/tapir/internal/adapters/store"
|
|
"git.d-ma.be/mathias/tapir/internal/domain"
|
|
"git.d-ma.be/mathias/tapir/internal/uploads"
|
|
)
|
|
|
|
// Uploader accepts an uploaded recording for transcription (ADR-033).
|
|
// *uploads.Intake satisfies it. It is the whole of what the handlers know about
|
|
// validation, spooling and queueing.
|
|
type Uploader interface {
|
|
Accept(ctx context.Context, userID, title string, src io.Reader) (id string, err error)
|
|
}
|
|
|
|
const (
|
|
// uploadOverhead is headroom above the file-size cap for the multipart framing
|
|
// and the title field; the cap itself is enforced on the file part by Intake.
|
|
uploadOverhead = 1 << 20
|
|
maxTitleRunes = 200
|
|
// uploadPollEvery is how often an unfinished upload re-asks for its status.
|
|
uploadPollEvery = "5s"
|
|
)
|
|
|
|
// uploadsView is what the /uploads page renders.
|
|
type uploadsView struct {
|
|
Limits uploads.Limits
|
|
Rows []domain.UploadedTranscript
|
|
Error string // a synchronous rejection message, empty when none
|
|
}
|
|
|
|
// handleUploadsPage renders the upload form and the caller's own uploads.
|
|
func (a *App) handleUploadsPage(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := a.currentUserID(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.renderUploadsPage(w, r, userID, http.StatusOK, "")
|
|
}
|
|
|
|
func (a *App) renderUploadsPage(w http.ResponseWriter, r *http.Request, userID string, status int, msg string) {
|
|
rows, err := a.Store.ListUploads(r.Context(), userID)
|
|
if err != nil {
|
|
a.serverError(w, r, "list uploads", err)
|
|
return
|
|
}
|
|
a.renderStatus(w, r, status, UploadsPage(uploadsView{Limits: a.UploadLimits, Rows: rows, Error: msg}))
|
|
}
|
|
|
|
// handleUploadPost streams the multipart body: the optional title field, then the
|
|
// file part, which goes straight to Intake without being buffered in memory. A
|
|
// rejection is synchronous — a status code and a message on the upload page, no
|
|
// row, no timeout (ADR-033).
|
|
func (a *App) handleUploadPost(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := a.currentUserID(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, a.UploadLimits.MaxBytes+uploadOverhead)
|
|
mr, err := r.MultipartReader()
|
|
if err != nil {
|
|
a.renderUploadsPage(w, r, userID, http.StatusBadRequest, "Choose an audio file to upload.")
|
|
return
|
|
}
|
|
title := ""
|
|
for {
|
|
part, err := mr.NextPart()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
a.uploadFailure(w, r, userID, err)
|
|
return
|
|
}
|
|
switch part.FormName() {
|
|
case "title":
|
|
b, _ := io.ReadAll(io.LimitReader(part, maxTitleRunes*utf8.UTFMax))
|
|
title = clipRunes(strings.TrimSpace(string(b)), maxTitleRunes)
|
|
case "file":
|
|
if title == "" {
|
|
title = titleFromFilename(part.FileName())
|
|
}
|
|
id, err := a.Uploads.Accept(r.Context(), userID, title, part)
|
|
if err != nil {
|
|
a.uploadFailure(w, r, userID, err)
|
|
return
|
|
}
|
|
http.Redirect(w, r, "/uploads/"+id, http.StatusSeeOther)
|
|
return
|
|
}
|
|
}
|
|
a.renderUploadsPage(w, r, userID, http.StatusBadRequest, "Choose an audio file to upload.")
|
|
}
|
|
|
|
// uploadFailure maps an Accept (or multipart) error to a response: a validation
|
|
// rejection is the user's to fix (422, or 413 for size) and carries its own
|
|
// message; anything else is ours.
|
|
func (a *App) uploadFailure(w http.ResponseWriter, r *http.Request, userID string, err error) {
|
|
var rej *uploads.RejectError
|
|
var tooBig *http.MaxBytesError
|
|
switch {
|
|
case errors.As(err, &rej):
|
|
// Logged by reason only: the filename and title are private content.
|
|
a.logger().Info("upload rejected", "reason", string(rej.Reason))
|
|
status := http.StatusUnprocessableEntity
|
|
if rej.Reason == uploads.ReasonTooLarge {
|
|
status = http.StatusRequestEntityTooLarge
|
|
}
|
|
a.renderUploadsPage(w, r, userID, status, rej.Message)
|
|
case errors.As(err, &tooBig):
|
|
a.logger().Info("upload rejected", "reason", string(uploads.ReasonTooLarge))
|
|
a.renderUploadsPage(w, r, userID, http.StatusRequestEntityTooLarge,
|
|
"This file is larger than the upload limit.")
|
|
default:
|
|
a.serverError(w, r, "upload", err)
|
|
}
|
|
}
|
|
|
|
// handleUploadDetail renders one upload's page (GET /uploads/{id}). The row is
|
|
// read through the user-scoped store, so another user's id is a 404 — existence is
|
|
// not disclosed, and the title never appears in the response.
|
|
func (a *App) handleUploadDetail(w http.ResponseWriter, r *http.Request) {
|
|
u, ok := a.loadOwnedUpload(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.render(w, r, UploadPage(*u, a.Chat != nil))
|
|
}
|
|
|
|
// handleUploadStatus renders the status fragment HTMX polls. Unfinished states
|
|
// keep polling; terminal states render without hx-trigger so the page stops
|
|
// asking (ADR-025: never a stuck spinner).
|
|
func (a *App) handleUploadStatus(w http.ResponseWriter, r *http.Request) {
|
|
u, ok := a.loadOwnedUpload(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
a.render(w, r, uploadStatus(*u, a.Chat != nil))
|
|
}
|
|
|
|
func (a *App) loadOwnedUpload(w http.ResponseWriter, r *http.Request) (*domain.UploadedTranscript, bool) {
|
|
userID, ok := a.currentUserID(w, r)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
u, err := a.Store.GetUpload(r.Context(), userID, r.PathValue("id"))
|
|
if errors.Is(err, store.ErrUploadNotFound) {
|
|
http.NotFound(w, r)
|
|
return nil, false
|
|
}
|
|
if err != nil {
|
|
a.serverError(w, r, "get upload", err)
|
|
return nil, false
|
|
}
|
|
return u, true
|
|
}
|
|
|
|
// titleFromFilename is the default title: the file's name without its extension.
|
|
func titleFromFilename(name string) string {
|
|
base := filepath.Base(name)
|
|
t := strings.TrimSuffix(base, filepath.Ext(base))
|
|
if t == "" || t == "." {
|
|
return "Untitled recording"
|
|
}
|
|
return clipRunes(t, maxTitleRunes)
|
|
}
|
|
|
|
func clipRunes(s string, n int) string {
|
|
if utf8.RuneCountInString(s) <= n {
|
|
return s
|
|
}
|
|
return string([]rune(s)[:n])
|
|
}
|
|
|
|
// uploadFailureMessage turns a typed failure kind into words for the user. It is
|
|
// keyed on OUR kinds, never on a provider's error string (ADR-033).
|
|
func uploadFailureMessage(k domain.UploadErrorKind) string {
|
|
switch k {
|
|
case domain.UploadErrInterrupted:
|
|
return "The server restarted before this recording was transcribed. Please upload it again."
|
|
case domain.UploadErrTranscriptionFailed:
|
|
return "Transcription failed on every available service. Please upload it again later."
|
|
default:
|
|
return "This upload failed. Please upload it again."
|
|
}
|
|
}
|
|
|
|
// handleUploadChat renders the chat page for a FINISHED upload (GET). The row is
|
|
// read through the user-scoped store, so another user's id is a 404 before any
|
|
// model is involved. An unfinished upload has no transcript to ask about yet, so
|
|
// it goes back to its status page.
|
|
func (a *App) handleUploadChat(w http.ResponseWriter, r *http.Request) {
|
|
u, ok := a.loadOwnedUpload(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if u.Status != domain.UploadDone {
|
|
http.Redirect(w, r, "/uploads/"+u.ID, http.StatusSeeOther)
|
|
return
|
|
}
|
|
a.render(w, r, UploadChatPage(*u, a.uploadChatView(*u, a.Chat.DefaultModel(a.UploadChatModel), nil, false, "")))
|
|
}
|
|
|
|
// handleUploadChatMessage answers one question against the owner's uploaded
|
|
// transcript (POST), reusing the ADR-027 Chatter. Nothing is persisted: the prior
|
|
// turns ride in the form. The transcript goes to the model with the UPLOAD budget,
|
|
// not the caption default. A model failure is inline, not a 500.
|
|
func (a *App) handleUploadChatMessage(w http.ResponseWriter, r *http.Request) {
|
|
u, ok := a.loadOwnedUpload(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
if u.Status != domain.UploadDone {
|
|
http.Redirect(w, r, "/uploads/"+u.ID, http.StatusSeeOther)
|
|
return
|
|
}
|
|
if err := r.ParseForm(); err != nil {
|
|
http.Error(w, "bad form", http.StatusBadRequest)
|
|
return
|
|
}
|
|
model := a.resolveModel(r.FormValue("model"), a.UploadChatModel)
|
|
history := parseHistory(r.Form["hq"], r.Form["ha"])
|
|
question := strings.TrimSpace(r.FormValue("question"))
|
|
|
|
view := a.uploadChatView(*u, model, history, false, "")
|
|
if question != "" {
|
|
reply, err := a.Chat.Answer(r.Context(), chat.Request{
|
|
Model: model,
|
|
Transcript: u.Content,
|
|
History: history,
|
|
Question: question,
|
|
MaxChars: a.UploadChatMaxChars,
|
|
})
|
|
if err != nil {
|
|
a.logger().Error("upload chat answer", "upload", u.ID, "model", model, "err", err)
|
|
view.Error = "That model couldn't answer just now. Try again, or switch models."
|
|
} else {
|
|
view.History = appendTurn(history, chat.Turn{Question: question, Answer: reply.Answer})
|
|
view.Truncated = reply.Truncated
|
|
}
|
|
}
|
|
if isHTMX(r) {
|
|
a.render(w, r, chatPanel(view))
|
|
return
|
|
}
|
|
a.render(w, r, UploadChatPage(*u, view))
|
|
}
|
|
|
|
func (a *App) uploadChatView(u domain.UploadedTranscript, model string, history []chat.Turn, truncated bool, errMsg string) chatView {
|
|
return chatView{
|
|
VideoID: u.ID,
|
|
Title: u.Title,
|
|
Available: true,
|
|
Models: a.Chat.Models(),
|
|
Selected: model,
|
|
History: history,
|
|
Truncated: truncated,
|
|
Error: errMsg,
|
|
PostURL: templ.SafeURL("/uploads/" + u.ID + "/chat"),
|
|
Subject: "recording",
|
|
}
|
|
}
|