feat(federation): peer-lifecycle presence hooks (snapshot on activate, mark-offline on deactivate)

onPeerActivated re-emits a presence_update for every relationship-related online native to the activating peer (relationship = friend with peer-stub / DM-mate with peer-stub / replicatedInstances opt-in for peer origin). Scope bounded by relationship count, not native count — flap recovery cost stays proportional to actual interaction surface. onPeerDeactivated flips every replicated stub from that peer to offline and broadcasts a local presence_update so connected friends/DM-mates/space-co-members see them disappear immediately, instead of seeing stale online until next signal. Re-snapshot on every activation (incl. health-check unreachable→active flap) is load-bearing for correctness — markPeerStubsOffline ran on the prior deactivation and presence is not in the mutation log.
2026-05-05 16:12:22 +02:00
parent ad1a0f7164
commit 1cb151d3a9
3 changed files with 352 additions and 2 deletions
@@ -1,8 +1,10 @@
-import { eq } from 'drizzle-orm';
-import type { Activity, FederationRelayEvent, FederationPresenceUpdatePayload } from '@backspace/shared';
+import { and, eq, inArray, isNull, or } from 'drizzle-orm';
+import type { Activity, FederationRelayEvent, FederationPresenceUpdatePayload, ReplicatedInstance } from '@backspace/shared';
 import { getDb, schema } from '../db/index.js';
 import { getOurOrigin } from './federationAuth.js';
 import { isFederationRelayEnabled, queueOutboxEvent } from './federationOutbox.js';
+import { collectProfileBroadcastTargetIds } from './userDeletion.js';
+import { extractDomain } from '../routes/federation.js';

 export type PresenceStatus = 'online' | 'idle' | 'dnd' | 'offline';

@@ -59,3 +61,166 @@ export function queuePresenceRelay(
    'profile',
  );
 }
+
+/**
+ * On peer activation, send a fresh presence snapshot to the newly-active peer
+ * for every online local native user that has an S2S relationship with that
+ * peer (so the peer's stubs reflect current reality — presence is outbox-only,
+ * no mutation-log replay can do this).
+ *
+ * Scope is bounded by relationship count, not native count. A native qualifies
+ * if ANY of:
+ *   - friend with at least one stub whose home_instance = peer domain
+ *   - DM-member (closed=0) with at least one stub whose home_instance = peer domain
+ *   - replicatedInstances JSON includes peerOrigin (explicit client-federation opt-in)
+ *
+ * Re-runs on every activation (including health-check unreachable→active flaps),
+ * because markPeerStubsOffline ran on deactivation — peers and our stubs both
+ * need a fresh handshake on recovery, not a stale-window-skip.
+ */
+export function snapshotPresenceForPeer(peerOrigin: string): void {
+  if (!isFederationRelayEnabled()) return;
+
+  const db = getDb();
+  const peerDomain = extractDomain(peerOrigin);
+
+  // 1. All stubs from this peer that exist locally.
+  const peerStubIdList = db
+    .select({ id: schema.users.id })
+    .from(schema.users)
+    .where(and(
+      eq(schema.users.homeInstance, peerDomain),
+      eq(schema.users.isDeleted, 0),
+    ))
+    .all()
+    .map((s) => s.id);
+  const peerStubIds = new Set(peerStubIdList); // O(1) membership tests in the friend loop
+
+  // 2. Build the set of native IDs related to those stubs (friends + DM co-members).
+  const relatedNativeIds = new Set<string>();
+  if (peerStubIdList.length > 0) {
+    const friendRows = db.select().from(schema.friends)
+      .where(or(
+        inArray(schema.friends.userId, peerStubIdList),
+        inArray(schema.friends.friendId, peerStubIdList),
+      ))
+      .all();
+    for (const f of friendRows) {
+      const stubSide = peerStubIds.has(f.userId) ? f.userId : f.friendId;
+      const otherSide = stubSide === f.userId ? f.friendId : f.userId;
+      relatedNativeIds.add(otherSide);
+    }
+
+    // Stub's DM memberships — filter closed=0 so DMs the stub left don't pull
+    // their old co-members into snapshot scope.
+    const stubDmIds = db.select({ dmChannelId: schema.dmMembers.dmChannelId })
+      .from(schema.dmMembers)
+      .where(and(
+        inArray(schema.dmMembers.userId, peerStubIdList),
+        eq(schema.dmMembers.closed, 0),
+      ))
+      .all()
+      .map((d) => d.dmChannelId);
+    if (stubDmIds.length > 0) {
+      // Co-members — filter closed=0 so a native who closed the DM locally
+      // doesn't receive snapshots for its lingering stub.
+      const dmCoMembers = db.select({ userId: schema.dmMembers.userId })
+        .from(schema.dmMembers)
+        .where(and(
+          inArray(schema.dmMembers.dmChannelId, stubDmIds),
+          eq(schema.dmMembers.closed, 0),
+        ))
+        .all();
+      for (const m of dmCoMembers) relatedNativeIds.add(m.userId);
+    }
+  }
+
+  // 3. Add explicit client-federation opt-ins via replicatedInstances JSON.
+  // (We can't index a JSON string in SQLite, so scan natives once and parse.)
+  // SCALING NOTE: this full-natives scan is fine pre-launch and remains cheap
+  // for instances under ~10k users. If population grows past that, replace with
+  // a `user_replicated_instance_index` table populated when replicatedInstances
+  // is written, indexed on (origin) for direct EXISTS lookup.
+  const allNatives = db.select().from(schema.users)
+    .where(and(
+      isNull(schema.users.homeInstance),
+      eq(schema.users.isDeleted, 0),
+    ))
+    .all();
+  for (const u of allNatives) {
+    if (!u.replicatedInstances) continue;
+    try {
+      const list = JSON.parse(u.replicatedInstances) as ReplicatedInstance[];
+      if (list.some((ri) => ri.origin === peerOrigin)) relatedNativeIds.add(u.id);
+    } catch { /* malformed JSON — skip */ }
+  }
+
+  // 4. Filter to online natives in the related set; emit one outbox event each.
+  for (const u of allNatives) {
+    if (!relatedNativeIds.has(u.id)) continue;
+    if (!u.status || u.status === 'offline') continue;
+    if (u.homeInstance) continue; // belt-and-braces: must be native
+
+    const ts = Date.now();
+    const event: FederationRelayEvent = {
+      eventType: 'presence_update',
+      contextType: 'profile',
+      messageId: `presence:${u.id}:${ts}:snap`,
+      encryptionVersion: 0,
+      timestamp: ts,
+      presenceUpdate: {
+        homeUserId: u.id,
+        homeInstance: getOurOrigin(),
+        status: u.status as 'online' | 'idle' | 'dnd',
+        ts,
+      },
+    };
+    queueOutboxEvent(u.id, u.id, 'presence_update', JSON.stringify(event), [peerOrigin], 'profile');
+  }
+}
+
+/**
+ * On peer deactivation (status flipping out of 'active'), flip all replicated
+ * stubs whose home is that peer to status='offline' and broadcast a local
+ * presence_update so connected friends/DM-mates/space-co-members see them go
+ * offline immediately.
+ *
+ * Imported lazily by onPeerDeactivated to avoid an import cycle through
+ * ws/handler.js (connectionManager).
+ *
+ * Accepts an origin string; derives the bare domain via extractDomain so the
+ * caller doesn't need to handle that detail.
+ */
+export async function markPeerStubsOffline(peerOrigin: string): Promise<void> {
+  const peerDomain = extractDomain(peerOrigin);
+  const db = getDb();
+  const stubs = db
+    .select({ id: schema.users.id })
+    .from(schema.users)
+    .where(and(
+      eq(schema.users.homeInstance, peerDomain),
+      eq(schema.users.isDeleted, 0),
+    ))
+    .all();
+
+  if (stubs.length === 0) return;
+
+  // Lazy import keeps this module pure for tests that don't need ws/handler.
+  const { connectionManager } = await import('../ws/handler.js');
+
+  for (const stub of stubs) {
+    db.update(schema.users)
+      .set({ status: 'offline' })
+      .where(eq(schema.users.id, stub.id))
+      .run();
+
+    const targets = collectProfileBroadcastTargetIds(stub.id);
+    const payload = {
+      type: 'presence_update' as const,
+      userId: stub.id,
+      status: 'offline' as const,
+      activities: [] as Activity[],
+    };
+    for (const uid of targets) connectionManager.sendToUser(uid, payload);
+  }
+}