Let task agents use client Macs directly: bash, copy and hands

internal/server/clients.go

@@ -0,0 +1,56 @@
+package server
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os/exec"
+	"time"
+
+	"github.com/coder/websocket"
+
+	"g.fc.run/misc/byre/internal/clients"
+)
+
+func (s *Server) ConnectClient(w http.ResponseWriter, r *http.Request) {
+	host := r.Header.Get("Byre-Host")
+	if host == "" {
+		writeError(w, http.StatusBadRequest, errors.New("missing Byre-Host"))
+		return
+	}
+
+	ws, err := websocket.Accept(w, r, nil)
+	if err != nil {
+		slog.Warn("accept client websocket", "host", host, "err", err)
+		return
+	}
+	defer ws.CloseNow()
+
+	s.clients.Serve(r.Context(), ws, clients.Client{
+		Login:       actor(r),
+		Host:        host,
+		Commit:      r.Header.Get("Byre-Commit"),
+		ConnectedAt: time.Now().UTC(),
+	})
+}
+
+func (s *Server) GetClientTransfer(w http.ResponseWriter, r *http.Request, transferID string) {
+	t, ok := s.clients.Transfer(transferID)
+	if !ok {
+		writeError(w, http.StatusNotFound, fmt.Errorf("no transfer %s", transferID))
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/gzip")
+	cmd := exec.CommandContext(r.Context(), "tar", "-czf", "-", "-C", t.Dir, "--", t.Name)
+	cmd.Stdout = w
+	stderr := &bytes.Buffer{}
+	cmd.Stderr = stderr
+	err := cmd.Run()
+	if err != nil {
+		slog.Error("stream client transfer", "transfer", transferID, "dir", t.Dir, "name", t.Name, "err", err, "stderr", stderr.String())
+		panic(http.ErrAbortHandler)
+	}
+}

internal/server/inbox.go

@@ -1,12 +1,7 @@
 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"
@@ -41,63 +36,6 @@ func (s *Server) GetInboxItem(w http.ResponseWriter, r *http.Request, itemID str
 	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) {

internal/server/server.go

@@ -16,6 +16,7 @@ import (
 
 	"g.fc.run/misc/byre/internal/agents"
 	"g.fc.run/misc/byre/internal/api"
+	"g.fc.run/misc/byre/internal/clients"
 	"g.fc.run/misc/byre/internal/git"
 	"g.fc.run/misc/byre/internal/store"
 	"g.fc.run/misc/byre/internal/todo"
@@ -26,6 +27,7 @@ type Server struct {
 	store     *store.Store
 	agents    *agents.Manager
 	hub       *hub
+	clients   *clients.Registry
 	terminals *terminals
 	startedAt time.Time
 
@@ -43,6 +45,7 @@ func New(dataDir string, portFirst int) (*Server, error) {
 
 	s := &Server{
 		hub:       newHub(),
+		clients:   clients.New(),
 		terminals: newTerminals(),
 		startedAt: time.Now().UTC(),
 		users:     map[string]string{},
@@ -65,7 +68,7 @@ func New(dataDir string, portFirst int) (*Server, error) {
 		}
 	}
 
-	s.agents = agents.New(s.store, filepath.Join(dataDir, "worktrees"), filepath.Join(dataDir, "leads"), filepath.Join(dataDir, "codex"), s.status, s.createProject)
+	s.agents = agents.New(s.store, filepath.Join(dataDir, "worktrees"), filepath.Join(dataDir, "leads"), filepath.Join(dataDir, "codex"), s.status, s.createProject, s.clients)
 	err = s.agents.Recover(context.Background())
 	if err != nil {
 		s.store.Close()
@@ -81,7 +84,6 @@ func (s *Server) publish(events []api.Event) {
 		s.hub.publish(ev)
 	}
 	s.agents.Observe(events)
-	s.removeClosedBundles(events)
 	for _, ev := range events {
 		if (ev.Kind == "task.merged" || ev.Kind == "task.discarded") && ev.TaskId != nil {
 			s.terminals.close(*ev.TaskId)
@@ -134,7 +136,7 @@ func (s *Server) identify(next http.Handler) http.Handler {
 			return
 		}
 
-		if (r.Method != http.MethodGet && !automaticRequests[r.Pattern]) || humanGets[r.Pattern] {
+		if r.Method != http.MethodGet && !automaticRequests[r.Pattern] {
 			s.acted(login, r)
 		}
 
@@ -155,11 +157,6 @@ func (s *Server) clientsChanged() {
 var automaticRequests = map[string]bool{
 	"PUT /api/me/pane-focus":               true,
 	"PUT /api/tasks/{taskId}/summary-read": true,
-	"POST /api/inbox/{itemId}/runs":        true,
-}
-
-var humanGets = map[string]bool{
-	"GET /api/inbox/{itemId}/bundle": true,
 }
 
 func (s *Server) ensureUser(ctx context.Context, login, name string) error {