byre/internal/server/inbox.go

package server

import (
	"errors"
	"fmt"
	"io/fs"
	"log/slog"
	"net/http"
	"os"

	"g.fc.run/misc/byre/internal/api"
	"g.fc.run/misc/byre/internal/store"
)

func (s *Server) ListInbox(w http.ResponseWriter, r *http.Request, params api.ListInboxParams) {
	f := store.InboxFilter{State: api.Open}
	if params.ProjectId != nil {
		f.ProjectID = *params.ProjectId
	}
	if params.TaskId != nil {
		f.TaskID = *params.TaskId
	}
	if params.State != nil {
		f.State = *params.State
	}

	items, err := s.store.ListInbox(r.Context(), f)
	if err != nil {
		writeStoreError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, items)
}

func (s *Server) GetInboxItem(w http.ResponseWriter, r *http.Request, itemID string) {
	item, err := s.store.GetInboxItem(r.Context(), itemID)
	if err != nil {
		writeStoreError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, item)
}

func (s *Server) GetRunBundle(w http.ResponseWriter, r *http.Request, itemID string) {
	item, err := s.store.GetInboxItem(r.Context(), itemID)
	if err != nil {
		writeStoreError(w, err)
		return
	}
	if item.Kind != api.ClientRun {
		writeError(w, http.StatusBadRequest, fmt.Errorf("item %s is a %s, not a client_run", itemID, item.Kind))
		return
	}
	if item.State != api.Open {
		writeError(w, http.StatusConflict, fmt.Errorf("run request %s is %s", itemID, item.State))
		return
	}

	f, err := os.Open(s.store.BundlePath(itemID))
	if err != nil {
		writeError(w, http.StatusInternalServerError, err)
		return
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil {
		writeError(w, http.StatusInternalServerError, err)
		return
	}
	w.Header().Set("Content-Type", "application/gzip")
	http.ServeContent(w, r, "", info.ModTime(), f)
}

func (s *Server) ReportRun(w http.ResponseWriter, r *http.Request, itemID string) {
	req := api.RunReport{}
	if !readJSON(w, r, &req) {
		return
	}

	item, err := s.agents.ReportRun(r.Context(), actor(r), itemID, req)
	if err != nil {
		writeAgentError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, item)
}

func (s *Server) removeClosedBundles(events []api.Event) {
	for _, ev := range events {
		if ev.Kind != "inbox.updated" || ev.Payload["kind"] != string(api.ClientRun) || ev.Payload["state"] == string(api.Open) {
			continue
		}
		id, _ := ev.Payload["id"].(string)
		err := os.Remove(s.store.BundlePath(id))
		if err != nil && !errors.Is(err, fs.ErrNotExist) {
			slog.Error("remove run bundle", "item", id, "err", err)
		}
	}
}

func (s *Server) RespondInbox(w http.ResponseWriter, r *http.Request) {
	req := api.InboxRespond{}
	if !readJSON(w, r, &req) {
		return
	}
	for _, c := range req.Responses {
		_, ok := s.images(w, r, c.Images)
		if !ok {
			return
		}
	}

	items, err := s.agents.Respond(r.Context(), actor(r), req.Responses)
	if err != nil {
		writeAgentError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, items)
}