@saadnvd1/agent-os 0.3.698 → 0.3.715

package/lib/claims/store.ts

@@ -0,0 +1,366 @@
+import { randomUUID } from "crypto";
+import { getDb } from "../db";
+import {
+  CLAIM_TTL_MS,
+  OUTSIDE_TTL_MS,
+  asSource,
+  MAX_FILES,
+  MAX_HOPS,
+  REMOTE_TTL_CAP_MS,
+  TOMBSTONE_MS,
+  safePath,
+  type Claim,
+  type ClaimWire,
+  type Released,
+} from "./types";
+
+interface Row {
+  id: string;
+  origin: string;
+  origin_name: string;
+  via_machine: string | null;
+  hops: number;
+  source: string;
+  session_id: string | null;
+  session_name: string | null;
+  repo: string;
+  branch: string | null;
+  base: string | null;
+  goal: string;
+  files: string;
+  files_more: number;
+  pr_url: string | null;
+  started_at: number;
+  expires_at: number;
+  released: string | null;
+  updated_at: number;
+}
+
+// Another machine's text: no control characters, one line, short.
+export const cleanLine = (s: unknown, max: number) =>
+  String(s ?? "")
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, max);
+
+function parseFiles(raw: string): string[] {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
+const fromRow = (r: Row): Claim => ({
+  id: r.id,
+  origin: r.origin,
+  originName: r.origin_name,
+  viaMachine: r.via_machine,
+  hops: r.hops,
+  source: asSource(r.source),
+  sessionId: r.session_id,
+  sessionName: r.session_name,
+  repo: r.repo,
+  branch: r.branch,
+  base: r.base,
+  goal: r.goal,
+  files: parseFiles(r.files),
+  filesMore: r.files_more,
+  prUrl: r.pr_url,
+  startedAt: r.started_at,
+  expiresAt: r.expires_at,
+  released: (r.released as Released | null) ?? null,
+  updatedAt: r.updated_at,
+});
+
+const SELECT = `SELECT * FROM work_claims`;
+
+export interface LocalClaim {
+  sessionId: string;
+  sessionName: string;
+  repo: string;
+  branch: string | null;
+  base: string | null;
+  goal: string;
+  files: string[];
+  filesMore: number;
+  prUrl: string | null;
+}
+
+export const localClaimId = (sessionId: string) => `s-${sessionId}`;
+
+// Renews the claim for a local session; its start stays when it was first seen.
+export function upsertLocal(
+  origin: { id: string; name: string },
+  c: LocalClaim,
+  now = Date.now()
+): void {
+  const id = localClaimId(c.sessionId);
+  const files = c.files.filter(safePath).slice(0, MAX_FILES);
+  getDb()
+    .prepare(
+      `INSERT INTO work_claims (id, origin, origin_name, hops, source, session_id,
+         session_name, repo, branch, base, goal, files, files_more, pr_url,
+         started_at, expires_at, released, updated_at)
+       VALUES (@id, @origin, @originName, 0, 'session', @sessionId, @sessionName,
+         @repo, @branch, @base, @goal, @files, @filesMore, @prUrl,
+         @now, @expires, NULL, @now)
+       ON CONFLICT(id) DO UPDATE SET origin_name = @originName,
+         session_name = @sessionName, repo = @repo, branch = @branch, base = @base,
+         goal = @goal, files = @files, files_more = @filesMore, pr_url = @prUrl,
+         expires_at = @expires, released = NULL, updated_at = @now`
+    )
+    .run({
+      id,
+      origin: origin.id,
+      originName: cleanLine(origin.name, 60),
+      sessionId: c.sessionId,
+      sessionName: cleanLine(c.sessionName, 120),
+      repo: c.repo,
+      branch: c.branch,
+      base: c.base,
+      goal: cleanLine(c.goal, 120) || "(unnamed)",
+      files: JSON.stringify(files),
+      filesMore: c.filesMore + Math.max(0, c.files.length - files.length),
+      prUrl: c.prUrl,
+      now,
+      expires: now + CLAIM_TTL_MS,
+    });
+}
+
+// Ends a local claim, kept as a tombstone so the release reaches the peers.
+export function release(
+  sessionId: string,
+  why: Released,
+  now = Date.now()
+): void {
+  getDb()
+    .prepare(
+      `UPDATE work_claims SET released = ?, expires_at = ?, updated_at = ?
+       WHERE id = ? AND (released IS NULL OR released != ?)`
+    )
+    .run(why, now + TOMBSTONE_MS, now, localClaimId(sessionId), why);
+}
+
+export interface OutsideClaim {
+  id: string;
+  sessionName: string | null;
+  repo: string;
+  branch: string | null;
+  base: string | null;
+  goal: string;
+  files: string[];
+}
+
+export const newOutsideId = () => `o-${randomUUID()}`;
+
+// Registers or renews a claim for a session AgentOS didn't start. It lives
+// OUTSIDE_TTL_MS from its last touch. False when the id is another claim's.
+export function upsertOutside(
+  origin: { id: string; name: string },
+  c: OutsideClaim,
+  now = Date.now()
+): boolean {
+  const db = getDb();
+  const have = db
+    .prepare(`SELECT origin, source FROM work_claims WHERE id = ?`)
+    .get(c.id) as { origin: string; source: string } | undefined;
+  if (have && (have.origin !== origin.id || have.source !== "outside"))
+    return false;
+  const files = c.files.map((f) => f.trim()).filter(safePath);
+  const kept = files.slice(0, MAX_FILES);
+  db.prepare(
+    `INSERT INTO work_claims (id, origin, origin_name, hops, source, session_id,
+       session_name, repo, branch, base, goal, files, files_more, pr_url,
+       started_at, expires_at, released, updated_at)
+     VALUES (@id, @origin, @originName, 0, 'outside', NULL, @sessionName,
+       @repo, @branch, @base, @goal, @files, @filesMore, NULL,
+       @now, @expires, NULL, @now)
+     ON CONFLICT(id) DO UPDATE SET origin_name = @originName,
+       session_name = @sessionName, repo = @repo, branch = @branch, base = @base,
+       goal = @goal, files = @files, files_more = @filesMore,
+       expires_at = @expires, released = NULL, updated_at = @now`
+  ).run({
+    id: c.id,
+    origin: origin.id,
+    originName: cleanLine(origin.name, 60),
+    sessionName: cleanLine(c.sessionName, 120) || null,
+    repo: c.repo,
+    branch: cleanLine(c.branch, 250) || null,
+    base: cleanLine(c.base, 250) || null,
+    goal: cleanLine(c.goal, 120) || "(unnamed)",
+    files: JSON.stringify(kept),
+    filesMore: Math.max(0, files.length - kept.length),
+    now,
+    expires: now + OUTSIDE_TTL_MS,
+  });
+  return true;
+}
+
+// Ends an outside claim of this machine; a task's or a peer's is refused.
+export function releaseOutside(
+  self: string,
+  id: string,
+  now = Date.now()
+): "ended" | "missing" | "forbidden" {
+  const row = getDb()
+    .prepare(`SELECT origin, source FROM work_claims WHERE id = ?`)
+    .get(id) as { origin: string; source: string } | undefined;
+  if (!row) return "missing";
+  if (row.origin !== self || row.source !== "outside") return "forbidden";
+  getDb()
+    .prepare(
+      `UPDATE work_claims SET released = 'done', expires_at = ?, updated_at = ?
+       WHERE id = ? AND released IS NULL`
+    )
+    .run(now + TOMBSTONE_MS, now, id);
+  return "ended";
+}
+
+// Takes one claim a peer sent. Returns whether it was stored. The row with
+// the most life wins, unless a nearer copy (fewer hops) says something newer.
+export function upsertRemote(
+  self: string,
+  sender: string,
+  w: ClaimWire,
+  now = Date.now(),
+  viaHost: string | null = null
+): boolean {
+  if (w.origin === self || w.hops > MAX_HOPS) return false;
+  const files = w.files.map((f) => f.trim()).filter(safePath);
+  const expires = now + Math.min(w.ttl_s * 1000, REMOTE_TTL_CAP_MS);
+  if (expires <= now) return false;
+  const db = getDb();
+  const have = db.prepare(`${SELECT} WHERE id = ?`).get(w.id) as
+    Row | undefined;
+  if (have) {
+    if (have.origin === self) return false;
+    if (have.released && !w.released && have.expires_at >= expires)
+      return false;
+    if (expires <= have.expires_at && w.hops >= have.hops) return false;
+  }
+  db.prepare(
+    `INSERT INTO work_claims (id, origin, origin_name, via_machine, via_host, hops, source,
+       session_id, session_name, repo, branch, base, goal, files, files_more,
+       pr_url, started_at, expires_at, released, updated_at)
+     VALUES (@id, @origin, @originName, @via, @viaHost, @hops, @source, NULL, @sessionName,
+       @repo, @branch, @base, @goal, @files, @filesMore, @prUrl, @started,
+       @expires, @released, @now)
+     ON CONFLICT(id) DO UPDATE SET origin_name = @originName, via_machine = @via, via_host = COALESCE(@viaHost, via_host),
+       hops = @hops, session_name = @sessionName, repo = @repo, branch = @branch,
+       base = @base, goal = @goal, files = @files, files_more = @filesMore,
+       pr_url = @prUrl, started_at = MIN(started_at, @started),
+       expires_at = @expires, released = @released, updated_at = @now`
+  ).run({
+    id: w.id,
+    origin: w.origin,
+    originName: cleanLine(w.origin_name, 60) || "machine",
+    via: sender,
+    viaHost,
+    hops: w.hops,
+    source: asSource(w.source),
+    sessionName: cleanLine(w.session_name, 120) || null,
+    repo: cleanLine(w.repo, 300).toLowerCase(),
+    branch: cleanLine(w.branch, 250) || null,
+    base: cleanLine(w.base, 250) || null,
+    goal: cleanLine(w.goal, 120) || "(unnamed)",
+    files: JSON.stringify(files),
+    filesMore: w.files_more + Math.max(0, w.files.length - files.length),
+    prUrl: /^https?:\/\//.test(w.pr_url ?? "")
+      ? cleanLine(w.pr_url, 300)
+      : null,
+    started: now - Math.floor(w.age_s * 1000),
+    expires,
+    released: w.released ?? null,
+    now,
+  });
+  return true;
+}
+
+export function purgeExpired(now = Date.now()): number {
+  return getDb()
+    .prepare(`DELETE FROM work_claims WHERE expires_at <= ?`)
+    .run(now).changes;
+}
+
+export function liveClaims(
+  opts: { repo?: string; now?: number } = {}
+): Claim[] {
+  const rows = getDb()
+    .prepare(
+      `${SELECT} WHERE released IS NULL AND expires_at > @now
+         ${opts.repo ? "AND repo = @repo" : ""} ORDER BY started_at`
+    )
+    .all({
+      now: opts.now ?? Date.now(),
+      ...(opts.repo && { repo: opts.repo }),
+    }) as Row[];
+  return rows.map(fromRow);
+}
+
+// One claim by id while it is alive: not released, not expired. A wait on a
+// claim is over when this is null.
+export function liveClaim(id: string, now = Date.now()): Claim | null {
+  const r = getDb()
+    .prepare(`${SELECT} WHERE id = ? AND released IS NULL AND expires_at > ?`)
+    .get(id, now) as Row | undefined;
+  return r ? fromRow(r) : null;
+}
+
+// Local claims whose session is no longer worth claiming for.
+export function localLiveSessionIds(): string[] {
+  return (
+    getDb()
+      .prepare(
+        `SELECT session_id FROM work_claims
+         WHERE session_id IS NOT NULL AND released IS NULL`
+      )
+      .all() as { session_id: string }[]
+  ).map((r) => r.session_id);
+}
+
+// What goes to a peer: everything still alive or just released, except what
+// the peer itself told us and what is too many hops from its source.
+export function wireFor(
+  self: string,
+  peer: { machineId?: string | null } = {},
+  now = Date.now()
+): ClaimWire[] {
+  const rows = getDb()
+    .prepare(`${SELECT} WHERE expires_at > ?`)
+    .all(now) as Row[];
+  return rows
+    .filter(
+      (r) =>
+        r.hops < MAX_HOPS &&
+        (!peer.machineId ||
+          (r.origin !== peer.machineId && r.via_machine !== peer.machineId))
+    )
+    .map((r) => ({
+      id: r.id,
+      origin: r.origin,
+      origin_name: r.origin_name,
+      hops: r.origin === self ? 0 : r.hops + 1,
+      source: asSource(r.source),
+      session_name: r.session_name,
+      repo: r.repo,
+      branch: r.branch,
+      base: r.base,
+      goal: r.goal,
+      files: parseFiles(r.files).slice(0, MAX_FILES),
+      files_more: r.files_more,
+      pr_url: r.pr_url,
+      ttl_s: Math.max(0, Math.floor((r.expires_at - now) / 1000)),
+      age_s: Math.max(0, Math.floor((now - r.started_at) / 1000)),
+      released: (r.released as Released | null) ?? null,
+    }));
+}
+
+// One claim by id even when released: a tombstone says how it ended.
+export function claimById(id: string): Claim | null {
+  const r = getDb().prepare(`${SELECT} WHERE id = ?`).get(id) as
+    Row | undefined;
+  return r ? fromRow(r) : null;
+}

package/lib/claims/types.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+
+export const CLAIMS_SYNC_MS = 60_000;
+// A local session's claim, renewed every sync while the session lives.
+export const CLAIM_TTL_MS = 10 * 60_000;
+// An outside session's claim, renewed by its hook or `aos claim touch`.
+export const OUTSIDE_TTL_MS = 30 * 60_000;
+// The most life a peer can give a claim here.
+export const REMOTE_TTL_CAP_MS = 15 * 60_000;
+export const TOMBSTONE_MS = 15 * 60_000;
+export const MAX_WIRE_CLAIMS = 500;
+export const MAX_FILES = 300;
+export const MAX_HOPS = 2;
+
+export const CLAIM_SOURCES = ["session", "outside"] as const;
+export type ClaimSource = (typeof CLAIM_SOURCES)[number];
+export const asSource = (s: unknown): ClaimSource =>
+  s === "outside" ? "outside" : "session";
+export type Released = "done" | "merged" | "abandoned";
+
+export interface Claim {
+  id: string;
+  origin: string;
+  originName: string;
+  viaMachine: string | null;
+  hops: number;
+  source: ClaimSource;
+  sessionId: string | null;
+  sessionName: string | null;
+  repo: string;
+  branch: string | null;
+  base: string | null;
+  goal: string;
+  files: string[];
+  filesMore: number;
+  prUrl: string | null;
+  startedAt: number;
+  expiresAt: number;
+  released: Released | null;
+  updatedAt: number;
+}
+
+// A path in a diff: relative, inside the repo, short.
+export const safePath = (p: string) =>
+  p.length > 0 &&
+  p.length <= 300 &&
+  !p.startsWith("/") &&
+  !/^[a-zA-Z]:[\\/]/.test(p) &&
+  !p.includes("\0") &&
+  !p.split(/[\\/]/).includes("..");
+
+const text = (max: number) => z.string().max(max * 4);
+
+export const claimWire = z.object({
+  id: z.string().min(1).max(100),
+  origin: z.string().min(1).max(100),
+  origin_name: text(60),
+  hops: z.number().int().min(0).max(10).default(0),
+  source: z.string().max(20).default("session"),
+  session_name: text(120).nullable().optional(),
+  repo: z.string().min(3).max(300),
+  branch: z.string().max(250).nullable().optional(),
+  base: z.string().max(250).nullable().optional(),
+  goal: text(120),
+  files: z.array(z.string().max(300)).max(MAX_FILES),
+  files_more: z.number().int().min(0).max(1_000_000).default(0),
+  pr_url: z.string().max(300).nullable().optional(),
+  ttl_s: z.number().min(0).max(86_400),
+  age_s: z.number().min(0).max(31_536_000),
+  released: z.enum(["done", "merged", "abandoned"]).nullable().optional(),
+});
+export type ClaimWire = z.infer<typeof claimWire>;
+
+export const exchangeBody = z.object({
+  machine: z.object({ id: z.string().min(1).max(100), name: text(60) }),
+  claims: z.array(claimWire).max(MAX_WIRE_CLAIMS),
+});
+export type ExchangeBody = z.infer<typeof exchangeBody>;
+
+export interface Overlap {
+  a: Claim;
+  b: Claim;
+  kinds: ("branch" | "files" | "goal")[];
+  shared: string[];
+  strength: "strong" | "weak";
+}
+
+// What an outside session posts: its folder's remote URL, branch and the
+// paths of its diff. Never file contents.
+export const outsideBody = z.object({
+  id: z
+    .string()
+    .regex(/^o-[0-9a-f-]{36}$/)
+    .optional(),
+  remote: z.string().min(3).max(500),
+  branch: z.string().max(250).nullable().optional(),
+  base: z.string().max(250).nullable().optional(),
+  goal: text(120).optional(),
+  name: text(120).optional(),
+  files: z.array(z.string().max(300)).max(5000).default([]),
+});
+export type OutsideBody = z.infer<typeof outsideBody>;

package/lib/claims/view.ts

@@ -0,0 +1,80 @@
+// The claims as the UI and the mobile app read them: plain JSON, with the
+// pairs that overlap and when each machine was last heard from.
+
+import { getDb } from "../db";
+import { findOverlaps } from "./overlap";
+import { machineId, machineName } from "./machine";
+import type { Claim, Overlap } from "./types";
+
+export interface MachineView {
+  id: string;
+  name: string;
+  self: boolean;
+  // Epoch ms of the last claim or exchange from it; null for this machine.
+  lastHeardAt: number | null;
+}
+
+export interface OverlapView {
+  a: string;
+  b: string;
+  kinds: Overlap["kinds"];
+  shared: string[];
+  strength: Overlap["strength"];
+}
+
+export interface ClaimsView {
+  // The server's clock, so ages don't depend on the browser's.
+  now: number;
+  machine: { id: string; name: string };
+  machines: MachineView[];
+  claims: Claim[];
+  overlaps: OverlapView[];
+}
+
+export const overlapView = (o: Overlap): OverlapView => ({
+  a: o.a.id,
+  b: o.b.id,
+  kinds: o.kinds,
+  shared: o.shared,
+  strength: o.strength,
+});
+
+function peerSeen(): Map<string, number> {
+  const rows = getDb()
+    .prepare(
+      `SELECT machine_id, MAX(seen_at) AS seen FROM claim_peers GROUP BY machine_id`
+    )
+    .all() as { machine_id: string; seen: number }[];
+  return new Map(rows.map((r) => [r.machine_id, r.seen]));
+}
+
+export function machinesOf(claims: Claim[]): MachineView[] {
+  const self = machineId();
+  const seen = peerSeen();
+  const byId = new Map<string, MachineView>();
+  for (const c of claims) {
+    if (c.origin === self) continue;
+    const have = byId.get(c.origin);
+    const heard = Math.max(seen.get(c.origin) ?? 0, c.updatedAt);
+    byId.set(c.origin, {
+      id: c.origin,
+      name: c.originName,
+      self: false,
+      lastHeardAt: Math.max(have?.lastHeardAt ?? 0, heard),
+    });
+  }
+  return [
+    { id: self, name: machineName(), self: true, lastHeardAt: null },
+    ...[...byId.values()].sort((a, b) => a.name.localeCompare(b.name)),
+  ];
+}
+
+export function claimsView(claims: Claim[]): ClaimsView {
+  return {
+    now: Date.now(),
+    machine: { id: machineId(), name: machineName() },
+    machines: machinesOf(claims),
+    claims,
+    overlaps: findOverlaps(claims).map(overlapView),
+  };
+}

package/lib/claims/yield.ts

@@ -0,0 +1,24 @@
+// Which of two overlapping claims keeps going. Both servers must reach the
+// same answer without talking, so only fields both see are used.
+
+import type { Claim } from "./types";
+
+// Started times this close count as a tie: age_s crosses the wire in seconds.
+export const TIE_WINDOW_MS = 2 * 60_000;
+
+type Rank = Pick<Claim, "id" | "prUrl" | "startedAt">;
+
+// The claim that keeps going. An open PR beats none, then the earlier start,
+// then the lexically smaller id. Symmetric: winner(a, b) is winner(b, a).
+export function winner<T extends Rank>(a: T, b: T): T {
+  if (!!a.prUrl !== !!b.prUrl) return a.prUrl ? a : b;
+  if (Math.abs(a.startedAt - b.startedAt) > TIE_WINDOW_MS)
+    return a.startedAt < b.startedAt ? a : b;
+  return a.id < b.id ? a : b;
+}
+
+export const whoYields = <T extends Rank>(a: T, b: T): T =>
+  winner(a, b) === a ? b : a;
+
+export const pairKey = (a: Pick<Claim, "id">, b: Pick<Claim, "id">) =>
+  [a.id, b.id].sort().join("|");

package/lib/connect/control-api.ts

@@ -214,17 +214,123 @@ export async function requestTunnel(
   return { hostname: hostnameFrom(r), token: tokenFrom(r) };
 }
 
+/** What the account's plan allows; absent from an older Connect service. */
+export interface Entitlements {
+  plan: string;
+  linkMachines: boolean;
+  machineLimit: number;
+}
+
+export interface Beat {
+  enabled: boolean;
+  entitlements?: Entitlements;
+  /** Changes whenever the list `peers` would give changes. */
+  peersEtag?: string;
+}
+
+const ETAG = /^[A-Za-z0-9_-]{1,128}$/;
+
+export function entitlementsFrom(raw: unknown): Entitlements | undefined {
+  const e = (raw ?? null) as Record<string, unknown> | null;
+  if (!e || typeof e !== "object" || typeof e.link_machines !== "boolean")
+    return undefined;
+  return {
+    plan: typeof e.plan === "string" ? clean(e.plan, 32) : "unknown",
+    linkMachines: e.link_machines,
+    machineLimit:
+      typeof e.machine_limit === "number" &&
+      Number.isSafeInteger(e.machine_limit)
+        ? e.machine_limit
+        : 0,
+  };
+}
+
+const etagFrom = (raw: unknown) =>
+  typeof raw === "string" && ETAG.test(raw) ? raw : undefined;
+
 export async function heartbeat(
   config: ConnectConfig,
   privateKey: string,
   version: string
-) {
+): Promise<Beat> {
   const res = await signed(config, privateKey)(
     "POST",
     `/api/v1/machines/${config.machineId}/heartbeat`,
     { version }
   );
-  return (await res.json()) as { enabled: boolean };
+  const r = ((await res.json().catch(() => null)) ?? {}) as Record<
+    string,
+    unknown
+  >;
+  return {
+    enabled: r.enabled !== false,
+    entitlements: entitlementsFrom(r.entitlements),
+    peersEtag: etagFrom(r.peers_etag),
+  };
+}
+
+/** Another machine on this account, as the Connect service introduces it. */
+export interface ListedMachine {
+  id: string;
+  name: string;
+  hostname: string;
+  /** Its Ed25519 key as the service holds it: SPKI PEM. */
+  publicKey: string;
+  lastSeenAt: string | null;
+  version: string | null;
+}
+
+export interface PeerList {
+  entitlements?: Entitlements;
+  peersEtag?: string;
+  peers: ListedMachine[];
+}
+
+const MAX_PEERS = 100;
+
+/**
+ * The account's other machines this one may link to. Only an introduction:
+ * anything malformed is dropped here, and the keys still have to be
+ * confirmed by a person on both machines before either trusts the other.
+ */
+export async function listPeers(
+  config: ConnectConfig,
+  privateKey: string
+): Promise<PeerList> {
+  const res = await signed(config, privateKey)(
+    "GET",
+    `/api/v1/machines/${config.machineId}/peers`
+  );
+  const r = (await res.json().catch(() => null)) as Record<
+    string,
+    unknown
+  > | null;
+  if (!r || !Array.isArray(r.peers))
+    throw new Error("the Connect service sent no machine list");
+  const str = (v: unknown, max: number) =>
+    typeof v === "string" && v.length <= max ? v : null;
+  const peers: ListedMachine[] = [];
+  for (const raw of r.peers.slice(0, MAX_PEERS)) {
+    const m = (raw ?? {}) as Record<string, unknown>;
+    const id = str(m.id, 8);
+    const hostname = str(m.hostname, 253);
+    const publicKey = str(m.public_key, 1024);
+    if (!id || !MACHINE_ID.test(id) || !hostname || !publicKey) continue;
+    if (id === config.machineId) continue;
+    peers.push({
+      id,
+      name: clean(str(m.name, 500) ?? id, 80),
+      hostname,
+      publicKey,
+      lastSeenAt: str(m.last_seen_at, 64),
+      version: str(m.agent_os_version, 64),
+    });
+  }
+  return {
+    entitlements: entitlementsFrom(r.entitlements),
+    peersEtag: etagFrom(r.peers_etag),
+    peers,
+  };
 }
 
 export interface PushRequestBody {