@x47base/pocketbase-addon 0.1.0 → 0.2.0

package/scripts/check-edge.py

@@ -3,6 +3,7 @@
 import argparse
 import concurrent.futures
 import json
+import http.client
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -22,9 +23,9 @@ opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect
 def get(url):
     try:
         with opener.open(url, timeout=5) as response:
-            return response.status, response.read(65536)
+            return response.status, response.read((1 << 20) + 1)
     except urllib.error.HTTPError as error:
-        return error.code, error.read(65536)
+        return error.code, error.read((1 << 20) + 1)
 code, body = get(args.operator + '/edge/status')
 assert code == 200, 'operator status unavailable'
 before = json.loads(body)
@@ -32,11 +33,27 @@ assert before['policyReady'] and before['upstreamHealthy'], 'gateway not ready'
 with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
     codes = list(pool.map(lambda _: get(args.public + '/_/')[0], range(200)))
 assert all(code == 403 for code in codes), set(codes)
+# Send only a Content-Length header, never a gigabyte payload.
+public = urllib.parse.urlsplit(args.public)
+for _ in range(3):
+    connection = http.client.HTTPConnection(public.hostname, public.port, timeout=3)
+    try:
+        connection.putrequest('POST', '/api/health')
+        connection.putheader('Content-Length', str(1 << 30))
+        connection.endheaders()
+        response = connection.getresponse()
+        assert response.status == 413, 'oversized request was not rejected immediately'
+        response.read(1024)
+    finally:
+        connection.close()
 assert get(args.operator + '/edge/healthz')[0] == 204
 assert get(args.operator + '/edge/readyz')[0] == 204
 code, body = get(args.operator + '/edge/status')
 after = json.loads(body)
-assert after['rejected'] - before['rejected'] >= 200
-print(json.dumps({'blockedRequests': len(codes), 'healthCanary': 'passed',
+assert after['rejected'] - before['rejected'] >= 203
+assert after['reasons'].get('private_route', 0) - before['reasons'].get('private_route', 0) >= 200
+assert after['reasons'].get('body_too_large', 0) - before['reasons'].get('body_too_large', 0) >= 3
+assert any(i['reason'] == 'body_too_large' for i in after['incidents']), 'oversize event missing'
+print(json.dumps({'blockedRequests': len(codes) + 3, 'oversizeHeadersRejected': 3, 'healthCanary': 'passed',
                   'publicAcceptedDelta': after['accepted'] - before['accepted'],
                   'note': 'Zero accepted delta expected on an otherwise idle instance.'}))

package/scripts/check.sh

@@ -4,8 +4,11 @@ export GOWORK=off
 module=$(go list -m -f '{{.Version}} {{if .Replace}}REPLACED{{end}}' github.com/pocketbase/pocketbase)
 case "$module" in *REPLACED*) echo 'Compatibility checks must use unmodified upstream PocketBase' >&2; exit 1;; esac
 go test ./...
-go test -race ./edge ./security ./features ./localization ./loadtest ./backups ./settings ./mail ./admin ./otp ./watcher
+go test -race ./hosting ./multinode ./edge ./security ./features ./localization ./loadtest ./backups ./settings ./mail ./admin ./otp ./watcher
 go vet ./...
-node --test security/ui/*.test.mjs
+node --test security/ui/*.test.mjs bin/*.test.mjs
 go build -o /tmp/spink-pocketbase-check ./cmd/pocketbase
 go build -o /tmp/spink-edge-check ./cmd/edge
+
+go build -o /tmp/spink-gateway-check ./cmd/gateway
+go build -o /tmp/spink-hosting-check ./cmd/hosting

package/security/README.md

@@ -23,17 +23,28 @@ Unauthenticated clients share a source budget. Identity storage is capped and us
 process-local HMAC fingerprints; excess identities share an overflow bucket.
 Forwarded addresses are considered only for configured immediate proxy peers.
 
-Detection evaluates ten-second windows. Three consecutive high-rejection,
-authentication-failure or combined slow/failing windows open a suspected incident.
-Six clear windows resolve it. Legitimate load or client errors can trigger these
-patterns. The detector never installs blocking actions automatically. History is
-capped at 256 incidents. Missing traffic is not independent evidence of recovery;
-these are heuristic state transitions, not validated attack classification.
+Detection evaluates application traffic every second. A window with at least 20
+requests and a majority of rejections, over 80% authentication failures, or a
+majority of both slow and failing requests opens a suspected incident immediately.
+Evidence accumulates across suspicious windows; 60 seconds without a suspicious
+window resolves the application incident. Legitimate load or client errors can
+trigger these patterns. The detector never installs blocking actions automatically.
+History is capped at 256 incidents shared across application and firewall sources.
+These are heuristic transitions, not proof of attacker intent.
+
+The optional edge telemetry connection records **every public gateway rejection**
+immediately, including a single oversized upload. Events group by rejection reason
+until 60 seconds of silence; counters accumulate throughout the group. Upload size
+and timeout events are warning signals. Other groups become warnings at 20 denials
+in a rolling ten-second window; ordinary denials remain policy notices. The dashboard
+polls every two seconds while visible. Gateway snapshots publish every second and
+PocketBase imports them every second, so display latency is normally up to four
+seconds, subject to scheduler and I/O delays. Detection does not wait 30 seconds.
 
 ## Management
 
 Open `/_/#/security` through the Security tab after signing into the admin dashboard. It reuses the dashboard SDK session without copying tokens. Extension assets are public; APIs still require a superuser and an immediate peer in `ManagementPeers` (loopback by default). Logout/unmount cancels polling and discards old-session responses.
-Four concurrent management requests have a separate admission lane.
+Eight concurrent management requests have a separate admission lane.
 
 | Route | Behavior |
 | --- | --- |
@@ -51,12 +62,34 @@ Action body: `family`, `reason` (1–200 bytes), RFC3339 `expiresAt` in the next
 in enforce mode. Policy changes, acknowledgements, action changes/cancellation log
 operator identity. No endpoint exports a raw request body, token or query.
 
-Optional `StatePath` writes atomic private checkpoints every ten seconds, after
+Optional `StatePath` writes atomic private checkpoints every second, after
 management mutations and on shutdown. Validated policy, revision, incidents and
 unexpired actions survive restart; startup mode always wins. Corrupt/missing state
 falls back to startup configuration, with corruption reported as `storageDegraded`.
 Writes are best effort; an active policy can precede a failed disk write. This is
-not a transactional audit journal. Request counters/identities are process-local.
+not a transactional audit journal. Request counters/identities are process-local. Imported edge incident evidence and acknowledgement survive restart; firewall session counters reset with the gateway process.
+
+## Firewall telemetry
+
+Set `config.EdgeStatePath` (or `PB_SECURITY_EDGE_STATE_PATH` with the supplied
+binary) to the absolute path of the gateway snapshot. Start the gateway with
+`-telemetry /absolute/path/edge.json`. The Compose template configures a separate
+`telemetry` volume: the gateway can write it, PocketBase mounts it read-only.
+Keep the security policy volume read-only at the gateway. Telemetry is informational
+and never changes admission rules. Missing, invalid, or over-five-second-old
+snapshots show as unavailable/stale, retaining the last known values and incidents.
+
+Status includes `edge`, `edgeConfigured`, and `edgeStale`. Edge metrics distinguish
+HTTP arrivals, forwarded requests, rejected requests, payload bytes actually read,
+client-declared rejected bytes, upstream failures, active capacity and reason totals.
+Do not add application counters to edge counters: forwarded traffic appears at both
+stages. Counters exclude operator traffic, TCP/TLS/header-parse failures and traffic
+blocked by upstream infrastructure. Bytes are HTTP body bytes read by this process,
+not NIC bandwidth. A rejected Content-Length of 1 GiB does not mean 1 GiB arrived.
+Declared-size sums saturate at uint64 maximum rather than wrapping. No client IPs,
+URLs, queries, credentials or bodies are exported. Each snapshot is bounded to
+1 MiB, 60 time buckets and 128 edge events. The checkpoint is best-effort; a crash
+can lose the unpublished tail. Use infrastructure metrics for network-level attacks.
 
 ## Boundaries
 

package/security/config.go

@@ -9,6 +9,7 @@ import (
 
 type Config struct {
 	OperatorPeers         []string `json:"-"`
+	EdgeStatePath         string   `json:"-"`
 	StatePath             string   `json:"-"`
 	Mode                  string   `json:"mode"`
 	RequestsPerSecond     float64  `json:"requestsPerSecond"`
@@ -30,6 +31,9 @@ func DefaultConfig() Config {
 	return Config{Mode: "observe", RequestsPerSecond: 100, Burst: 200, IdentityPerSecond: 20, IdentityBurst: 40, MaxConcurrent: 64, MaxWrites: 8, MaxFiles: 8, MaxRealtime: 128, MaxSubscriptions: 100, MaxSubscriptionsTotal: 4096, MaxIdentities: 4096, ManagementPeers: []string{"127.0.0.0/8", "::1/128"}}
 }
 func (c Config) Validate() error {
+	if c.EdgeStatePath != "" && !filepath.IsAbs(c.EdgeStatePath) {
+		return errors.New("edge state path must be absolute")
+	}
 	if c.StatePath != "" && !filepath.IsAbs(c.StatePath) {
 		return errors.New("state path must be absolute")
 	}

package/security/edge_telemetry.go

@@ -0,0 +1,123 @@
+package security
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"strconv"
+	"time"
+)
+
+// EdgeTelemetry is an aggregate snapshot. It contains no request bodies, tokens or IPs.
+type EdgeTelemetry struct {
+	Version                int               `json:"version"`
+	Session                string            `json:"session"`
+	StartedAt              time.Time         `json:"startedAt"`
+	UpdatedAt              time.Time         `json:"updatedAt"`
+	PolicyReady            bool              `json:"policyReady"`
+	UpstreamHealthy        bool              `json:"upstreamHealthy"`
+	Active                 int               `json:"active"`
+	TrackedClients         int               `json:"trackedClients"`
+	Accepted               uint64            `json:"accepted"`
+	Requests               uint64            `json:"requests"`
+	Forwarded              uint64            `json:"forwarded"`
+	Rejected               uint64            `json:"rejected"`
+	BodyReadBytes          uint64            `json:"bodyReadBytes"`
+	DeclaredRejectedBytes  uint64            `json:"declaredRejectedBytes"`
+	UpstreamFailures       uint64            `json:"upstreamFailures"`
+	Reasons                map[string]uint64 `json:"reasons"`
+	Traffic                []TrafficWindow   `json:"traffic"`
+	Incidents              []Incident        `json:"incidents"`
+	MaxBodyBytes           int64             `json:"maxBodyBytes"`
+	BodyReadTimeoutSeconds int               `json:"bodyReadTimeoutSeconds"`
+	MaxConcurrent          int               `json:"maxConcurrent"`
+	MaxClientConcurrent    int               `json:"maxClientConcurrent"`
+}
+
+func (s *Service) readEdge(now time.Time) {
+	s.mu.Lock()
+	path := s.config.EdgeStatePath
+	s.mu.Unlock()
+	if path == "" {
+		return
+	}
+	snapshot, err := ReadEdgeTelemetry(path, now)
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.edgeError = err != nil
+	if err != nil {
+		return
+	}
+	s.edge = &snapshot
+	for i := range s.incidents {
+		if s.incidents[i].Source == "edge" && now.Sub(s.incidents[i].LastSeen) >= time.Minute {
+			s.incidents[i].Phase = "resolved"
+		}
+	}
+	sequence := uint64(0)
+	for _, incoming := range snapshot.Incidents {
+		sequence = max(sequence, incoming.ID)
+		sourceID := snapshot.Session + ":" + incoming.SourceID
+		found := -1
+		for i := range s.incidents {
+			if s.incidents[i].Source == "edge" && s.incidents[i].SourceID == sourceID {
+				found = i
+				break
+			}
+		}
+		incoming.SourceID = sourceID
+		if found >= 0 {
+			incoming.ID = s.incidents[found].ID
+			incoming.Acknowledged = s.incidents[found].Acknowledged
+			s.incidents[found] = incoming
+		} else {
+			if snapshot.Session == s.edgeSession && incoming.ID <= s.edgeSequence {
+				continue
+			}
+			s.nextID++
+			incoming.ID = s.nextID
+			s.incidents = append(s.incidents, incoming)
+			if len(s.incidents) > 256 {
+				s.incidents = s.incidents[1:]
+			}
+		}
+	}
+	s.edgeSequence = max(sequence, s.edgeSequenceIfSession(snapshot.Session))
+	s.edgeSession = snapshot.Session
+}
+
+func (s *Service) edgeSequenceIfSession(session string) uint64 {
+	if s.edgeSession == session {
+		return s.edgeSequence
+	}
+	return 0
+}
+
+func ReadEdgeTelemetry(path string, now time.Time) (EdgeTelemetry, error) {
+	var v EdgeTelemetry
+	f, err := os.Open(path)
+	if err != nil {
+		return v, err
+	}
+	defer f.Close()
+	raw, err := io.ReadAll(io.LimitReader(f, (1<<20)+1))
+	if err != nil {
+		return v, err
+	}
+	if len(raw) > 1<<20 {
+		return v, errors.New("edge telemetry too large")
+	}
+	if err = json.Unmarshal(raw, &v); err != nil {
+		return v, err
+	}
+	if v.Version != 1 || len(v.Session) != 32 || v.UpdatedAt.Before(now.Add(-5*time.Second)) || v.UpdatedAt.After(now.Add(5*time.Second)) || len(v.Incidents) > 128 || len(v.Traffic) > 60 || len(v.Reasons) > 32 {
+		return v, errors.New("invalid or stale edge telemetry")
+	}
+	for _, i := range v.Incidents {
+		if i.Source != "edge" || len(i.SourceID) > 64 || i.SourceID == "" || i.Family != "other" || len(i.Reason) > 64 || (i.Phase != "active" && i.Phase != "recovering" && i.Phase != "resolved") || i.ID == 0 || i.SourceID != strconv.FormatUint(i.ID, 10) {
+			return v, errors.New("invalid edge event")
+		}
+	}
+	return v, nil
+}

package/security/edge_telemetry_test.go

@@ -0,0 +1,87 @@
+package security
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestEdgeImportPersistsAndDoesNotDoubleCount(t *testing.T) {
+	dir := t.TempDir()
+	c := DefaultConfig()
+	c.StatePath = filepath.Join(dir, "state.json")
+	c.EdgeStatePath = filepath.Join(dir, "edge.json")
+	s, err := New(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Stop the ticker to make persistence and timestamp assertions deterministic.
+	close(s.stop)
+	<-s.done
+	now := time.Now()
+	v := EdgeTelemetry{Version: 1, Session: "01234567890123456789012345678901", UpdatedAt: now, Requests: 50, Rejected: 50, Incidents: []Incident{{ID: 1, Source: "edge", SourceID: "1", Family: "other", Reason: "client_rate", Phase: "active", FirstSeen: now, LastSeen: now, Evidence: Observation{Count: 50, Rejected: 50}}}}
+	write := func() {
+		b, _ := json.Marshal(v)
+		if err := os.WriteFile(c.EdgeStatePath, b, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write()
+	s.readEdge(now)
+	s.readEdge(now)
+	if len(s.incidents) != 1 || s.incidents[0].Evidence.Count != 50 || s.total != 0 {
+		t.Fatal("lost or duplicated edge evidence")
+	}
+	s.incidents[0].Acknowledged = true
+	v.Incidents[0].Evidence.Count = 70
+	v.Incidents[0].Evidence.Rejected = 70
+	write()
+	s.readEdge(now)
+	if len(s.incidents) != 1 || s.incidents[0].Evidence.Count != 70 || !s.incidents[0].Acknowledged {
+		t.Fatal("update lost acknowledgement")
+	}
+	s.persist()
+	saved := s.incidents
+	s.incidents = nil
+	s.readEdge(now)
+	if len(s.incidents) != 0 {
+		t.Fatal("evicted event reimported")
+	}
+	s.incidents = saved
+	restored, err := New(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer restored.Close()
+	if restored.config.EdgeStatePath != c.EdgeStatePath || len(restored.incidents) != 1 || restored.incidents[0].Evidence.Count != 70 {
+		t.Fatal("edge evidence or runtime path lost on restart")
+	}
+	s.readEdge(now.Add(6 * time.Second))
+	if !s.edgeError || s.edge == nil || s.edge.Incidents[0].Evidence.Count != 70 {
+		t.Fatal("staleness lost last known evidence")
+	}
+}
+func TestApplicationBurstDetectedInFirstWindowWithCumulativeEvidence(t *testing.T) {
+	s, err := New(DefaultConfig())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+	now := time.Now()
+	for j := 0; j < 30; j++ {
+		s.observe("reads", true, 429, 0)
+	}
+	s.evaluate(now)
+	if len(s.incidents) != 1 || s.incidents[0].Evidence.Count != 30 {
+		t.Fatal("short burst was lost")
+	}
+	for j := 0; j < 25; j++ {
+		s.observe("reads", true, 429, 0)
+	}
+	s.evaluate(now.Add(time.Second))
+	if s.incidents[0].Evidence.Count != 55 {
+		t.Fatal("evidence overwritten")
+	}
+}

package/security/management.go

@@ -23,7 +23,8 @@ func (s *Service) bindManagement(r *router.Router[*core.RequestEvent]) {
 	})
 	g.GET("/status", func(e *core.RequestEvent) error {
 		s.mu.Lock()
-		result := map[string]any{"mode": s.config.Mode, "revision": s.revision, "identities": len(s.identities), "active": maps.Clone(s.active), "observed": s.total, "rejected": s.rejected, "subscriptions": s.totalSubscriptions, "storageDegraded": s.storageError, "detector": "heuristic-v1", "actions": currentActions(s.actions, time.Now()), "startedAt": s.startedAt, "lastEvaluated": s.lastEvaluated, "traffic": append([]TrafficWindow{}, s.history...), "checkpointEnabled": s.config.StatePath != ""}
+		result := map[string]any{"edge": s.edge, "edgeConfigured": s.config.EdgeStatePath != "", "edgeStale": s.edgeError || s.edge != nil && time.Since(s.edge.UpdatedAt) > 5*time.Second,
+			"mode": s.config.Mode, "revision": s.revision, "identities": len(s.identities), "active": maps.Clone(s.active), "observed": s.total, "rejected": s.rejected, "subscriptions": s.totalSubscriptions, "storageDegraded": s.storageError, "detector": "heuristic-v2", "actions": currentActions(s.actions, time.Now()), "startedAt": s.startedAt, "lastEvaluated": s.lastEvaluated, "traffic": append([]TrafficWindow{}, s.history...), "checkpointEnabled": s.config.StatePath != ""}
 		s.mu.Unlock()
 		return e.JSON(http.StatusOK, result)
 	})
@@ -96,6 +97,7 @@ func (s *Service) bindManagement(r *router.Router[*core.RequestEvent]) {
 		}
 		c.OperatorPeers = s.config.OperatorPeers
 		c.StatePath = s.config.StatePath
+		c.EdgeStatePath = s.config.EdgeStatePath
 		s.config = cloneConfig(c)
 		s.revision++
 		revision := s.revision

package/security/openapi.json

@@ -152,6 +152,254 @@
             "description": "Must be within the next 15 minutes"
           }
         }
+      },
+      "EdgeTelemetry": {
+        "type": "object",
+        "properties": {
+          "version": {
+            "type": "integer"
+          },
+          "active": {
+            "type": "integer"
+          },
+          "trackedClients": {
+            "type": "integer"
+          },
+          "requests": {
+            "type": "integer"
+          },
+          "forwarded": {
+            "type": "integer"
+          },
+          "accepted": {
+            "type": "integer"
+          },
+          "rejected": {
+            "type": "integer"
+          },
+          "bodyReadBytes": {
+            "type": "integer"
+          },
+          "declaredRejectedBytes": {
+            "type": "integer"
+          },
+          "upstreamFailures": {
+            "type": "integer"
+          },
+          "maxBodyBytes": {
+            "type": "integer"
+          },
+          "bodyReadTimeoutSeconds": {
+            "type": "integer"
+          },
+          "maxConcurrent": {
+            "type": "integer"
+          },
+          "maxClientConcurrent": {
+            "type": "integer"
+          },
+          "session": {
+            "type": "string"
+          },
+          "startedAt": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "updatedAt": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "policyReady": {
+            "type": "boolean"
+          },
+          "upstreamHealthy": {
+            "type": "boolean"
+          },
+          "reasons": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "integer"
+            }
+          },
+          "traffic": {
+            "type": "array",
+            "maxItems": 60,
+            "items": {
+              "type": "object",
+              "properties": {
+                "at": {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                "seconds": {
+                  "type": "number"
+                },
+                "count": {
+                  "type": "integer"
+                },
+                "rejected": {
+                  "type": "integer"
+                },
+                "failures": {
+                  "type": "integer"
+                },
+                "slow": {
+                  "type": "integer"
+                }
+              }
+            }
+          },
+          "incidents": {
+            "type": "array",
+            "maxItems": 128,
+            "items": {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "integer"
+                },
+                "source": {
+                  "type": "string",
+                  "enum": [
+                    "edge",
+                    "pocketbase"
+                  ]
+                },
+                "sourceId": {
+                  "type": "string"
+                },
+                "reason": {
+                  "type": "string"
+                },
+                "severity": {
+                  "type": "string",
+                  "enum": [
+                    "notice",
+                    "warning"
+                  ]
+                },
+                "family": {
+                  "type": "string"
+                },
+                "phase": {
+                  "type": "string",
+                  "enum": [
+                    "active",
+                    "recovering",
+                    "resolved"
+                  ]
+                },
+                "firstSeen": {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                "lastSeen": {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                "acknowledged": {
+                  "type": "boolean"
+                },
+                "evidence": {
+                  "type": "object",
+                  "properties": {
+                    "count": {
+                      "type": "integer"
+                    },
+                    "rejected": {
+                      "type": "integer"
+                    },
+                    "failures": {
+                      "type": "integer"
+                    },
+                    "slow": {
+                      "type": "integer"
+                    },
+                    "bodyReadBytes": {
+                      "type": "integer"
+                    },
+                    "declaredRejectedBytes": {
+                      "type": "integer"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "Incident": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "source": {
+            "type": "string",
+            "enum": [
+              "edge",
+              "pocketbase"
+            ]
+          },
+          "sourceId": {
+            "type": "string"
+          },
+          "reason": {
+            "type": "string"
+          },
+          "severity": {
+            "type": "string",
+            "enum": [
+              "notice",
+              "warning"
+            ]
+          },
+          "family": {
+            "type": "string"
+          },
+          "phase": {
+            "type": "string",
+            "enum": [
+              "active",
+              "recovering",
+              "resolved"
+            ]
+          },
+          "firstSeen": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "lastSeen": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "acknowledged": {
+            "type": "boolean"
+          },
+          "evidence": {
+            "type": "object",
+            "properties": {
+              "count": {
+                "type": "integer"
+              },
+              "rejected": {
+                "type": "integer"
+              },
+              "failures": {
+                "type": "integer"
+              },
+              "slow": {
+                "type": "integer"
+              },
+              "bodyReadBytes": {
+                "type": "integer"
+              },
+              "declaredRejectedBytes": {
+                "type": "integer"
+              }
+            }
+          }
+        }
       }
     }
   },
@@ -204,6 +452,13 @@
                       "items": {
                         "type": "object",
                         "properties": {
+                          "at": {
+                            "type": "string",
+                            "format": "date-time"
+                          },
+                          "seconds": {
+                            "type": "number"
+                          },
                           "count": {
                             "type": "integer"
                           },
@@ -224,6 +479,20 @@
                       "additionalProperties": {
                         "$ref": "#/components/schemas/Action"
                       }
+                    },
+                    "edge": {
+                      "allOf": [
+                        {
+                          "$ref": "#/components/schemas/EdgeTelemetry"
+                        }
+                      ],
+                      "nullable": true
+                    },
+                    "edgeConfigured": {
+                      "type": "boolean"
+                    },
+                    "edgeStale": {
+                      "type": "boolean"
                     }
                   }
                 }