package main import ( "context" "encoding/json" "github.com/coder/websocket" "io" "net/http" "sort" "strings" "time" ) type managedDevice struct { ID string `json:"id"` Target *string `json:"target,omitempty"` ADBSerial *string `json:"adb_serial,omitempty"` ADBServer *string `json:"adb_server,omitempty"` DevicePort uint16 `json:"device_port"` Enabled bool `json:"enabled"` Connected bool `json:"connected"` LastError *string `json:"last_error"` } type managedStatus struct { ID string `json:"id"` Name string `json:"name"` Hostname string `json:"hostname"` OS string `json:"os"` Arch string `json:"arch"` Version string `json:"version"` PID uint32 `json:"pid"` Uptime uint64 `json:"uptime_seconds"` Supervised bool `json:"supervised"` Revision uint64 `json:"revision"` Instance string `json:"instance"` Devices []managedDevice `json:"devices"` } type manager struct { id string ws *websocket.Conn status managedStatus lastSeen int64 ctx context.Context cancel context.CancelFunc pending map[string]chan json.RawMessage } func (b *broker) managementAuth(handler http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if len(b.adminToken) < 32 { http.Error(w, "management admin token is not configured", 503) return } b.auth(b.adminToken, handler)(w, r) } } func (b *broker) redactManagement(data []byte) []byte { text := string(data) for _, secret := range []string{b.agentToken, b.clientToken, b.adminToken} { if secret != "" { text = strings.ReplaceAll(text, secret, "[REDACTED]") } } return []byte(text) } func (b *broker) managerRegister(w http.ResponseWriter, r *http.Request) { id := r.URL.Query().Get("agent") if !validID(id) { http.Error(w, "invalid agent ID", 400) return } b.mu.Lock() if old := b.managers[id]; old != nil && old.ctx.Err() == nil { b.mu.Unlock() http.Error(w, "agent already registered", 409) return } if b.managers[id] == nil && len(b.managers) >= 128 { b.mu.Unlock() http.Error(w, "agent registry full", 429) return } ctx, cancel := context.WithCancel(b.ctx) m := &manager{id: id, ctx: ctx, cancel: cancel, pending: map[string]chan json.RawMessage{}, status: managedStatus{ID: id, Devices: []managedDevice{}}, lastSeen: time.Now().Unix()} b.managers[id] = m b.mu.Unlock() defer func() { cancel(); b.mu.Lock(); m.ws = nil; b.mu.Unlock() }() ws, err := accept(w, r) if err != nil { return } defer ws.CloseNow() b.mu.Lock() m.ws = ws b.mu.Unlock() if writeJSON(ctx, ws, map[string]string{"type": "registered", "agent": id}) != nil { return } go func() { ticker := time.NewTicker(20 * time.Second) defer ticker.Stop() for { select { case <-ctx.Done(): return case <-ticker.C: deadline, stop := context.WithTimeout(ctx, 10*time.Second) err := ws.Ping(deadline) stop() if err != nil { cancel() return } } } }() for { typ, data, err := ws.Read(ctx) if err != nil || typ != websocket.MessageText { return } var message struct { Type string `json:"type"` RequestID string `json:"request_id"` Status managedStatus `json:"status"` Response json.RawMessage `json:"response"` } if json.Unmarshal(b.redactManagement(data), &message) != nil { return } switch message.Type { case "status": s := message.Status if s.ID != id || len(s.Name) > 128 || len(s.Hostname) > 256 || len(s.OS) > 64 || len(s.Arch) > 64 || len(s.Version) > 64 || len(s.Instance) > 128 || len(s.Devices) > 128 { return } for _, d := range s.Devices { if !validID(d.ID) || (d.Target != nil && len(*d.Target) > 256) || (d.ADBSerial != nil && len(*d.ADBSerial) > 256) || (d.LastError != nil && len(*d.LastError) > 2048) { return } } if s.Devices == nil { s.Devices = []managedDevice{} } b.mu.Lock() m.status = s m.lastSeen = time.Now().Unix() b.mu.Unlock() case "result": if len(message.Response) == 0 { return } var check struct { OK bool `json:"ok"` } if json.Unmarshal(message.Response, &check) != nil { return } b.mu.Lock() ch := m.pending[message.RequestID] b.mu.Unlock() if ch != nil { select { case ch <- message.Response: default: } } default: return } } } func isWebSocket(r *http.Request) bool { return strings.EqualFold(r.Header.Get("Upgrade"), "websocket") } func (b *broker) managersEndpoint(w http.ResponseWriter, r *http.Request) { type record struct { ID string `json:"id"` Online bool `json:"online"` LastSeen int64 `json:"last_seen"` Status managedStatus `json:"status"` } b.mu.Lock() records := []record{} for _, m := range b.managers { records = append(records, record{m.id, m.ws != nil, m.lastSeen, m.status}) } b.mu.Unlock() sort.Slice(records, func(i, j int) bool { return records[i].ID < records[j].ID }) if isWebSocket(r) { ws, err := accept(w, r) if err != nil { return } defer ws.CloseNow() writeJSON(r.Context(), ws, records) return } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(records) } func validManagementRequest(raw []byte) bool { var request struct { Op string `json:"op"` } if json.Unmarshal(raw, &request) != nil { return false } switch request.Op { case "status", "devices_list", "device_add", "device_remove", "device_enable", "config_get", "config_set", "logs", "restart": return true } return false } func (b *broker) managerRPC(ctx context.Context, id string, request json.RawMessage) json.RawMessage { failure := func(reason string) json.RawMessage { data, _ := json.Marshal(map[string]any{"ok": false, "error": reason}) return data } if !validID(id) || !validManagementRequest(request) { return failure("invalid management request") } b.mu.Lock() m := b.managers[id] if m == nil || m.ws == nil { b.mu.Unlock() return failure("agent is offline") } if len(m.pending) >= 16 { b.mu.Unlock() return failure("agent management request limit reached") } requestID := newID() response := make(chan json.RawMessage, 1) m.pending[requestID] = response ws := m.ws b.mu.Unlock() defer func() { b.mu.Lock(); delete(m.pending, requestID); b.mu.Unlock() }() deadline, cancel := context.WithTimeout(ctx, 15*time.Second) defer cancel() if writeJSON(deadline, ws, map[string]any{"type": "request", "request_id": requestID, "request": request}) != nil { return failure("cannot reach agent") } select { case data := <-response: return data case <-m.ctx.Done(): return failure("agent disconnected") case <-deadline.Done(): return failure("agent management request timed out") } } func (b *broker) managerRPCEndpoint(w http.ResponseWriter, r *http.Request) { var request []byte if isWebSocket(r) { ws, err := accept(w, r) if err != nil { return } defer ws.CloseNow() deadline, cancel := context.WithTimeout(r.Context(), 5*time.Second) defer cancel() typ, data, err := ws.Read(deadline) if err != nil || typ != websocket.MessageText || len(data) > 64*1024 { return } response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), data) writeJSON(r.Context(), ws, json.RawMessage(response)) return } if r.Method != "POST" { http.Error(w, "POST required", 405) return } var err error request, err = io.ReadAll(http.MaxBytesReader(w, r.Body, 64*1024)) if err != nil { http.Error(w, "request too large", 413) return } response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), request) w.Header().Set("Content-Type", "application/json") w.Write(response) }