oysterun 1.6.0-beta.2 → 1.6.0-beta.21

package/host-service/session-list-projection-service.mjs

@@ -0,0 +1,182 @@
+import { buildSessionSwitcherRows } from "./session-switcher-projection.mjs";
+
+// P236 R4: routes own authorization, eligibility and serializers. This service
+// assembles only their selected roster; dependencies retain storage ownership.
+export class SessionListProjectionService {
+  constructor({ readBindings, previewService, prepareDecorationRead, readTagLabels = () => new Map() }) {
+    this.readTagLabels = readTagLabels;
+    this.readBindings = readBindings;
+    this.previewService = previewService;
+    this.prepareDecorationRead = prepareDecorationRead;
+  }
+
+  metadata(liveSessions) {
+    const sessionRows = buildSessionSwitcherRows({ liveSessions, metadataOnly: true, tagLabels: this.readTagLabels() });
+    return {
+      status: "session_list_metadata",
+      session_switcher_metadata_contract: "routec.p236_live_session_metadata.v1",
+      session_rows: sessionRows,
+      session_count: sessionRows.length,
+    };
+  }
+
+  bindings(entries) {
+    const snapshot = this.readBindings(entries.map((entry) => entry.sessionId));
+    const selected = new Map();
+    for (const entry of entries) {
+      const binding = snapshot.get(entry.sessionId);
+      if (binding && (!entry.agentId || binding.host_agent_id === entry.agentId)) {
+        selected.set(entry.sessionId, binding);
+      }
+    }
+    return selected;
+  }
+
+  selectLiveBindings(bindingBySessionId, liveSessions) {
+    const selected = [];
+    for (const session of liveSessions) {
+      const sessionId = session.id || session.sessionId;
+      const binding = bindingBySessionId.get(sessionId);
+      if (!binding) {
+        throw new Error(
+          `Live Session unread projection requires a current Matrix binding: ${sessionId}`
+        );
+      }
+      selected.push(binding);
+    }
+    return selected;
+  }
+
+  liveBindings(liveSessions) {
+    const entries = liveSessions.map((session) => ({
+      sessionId: session.id || session.sessionId,
+      agentId: session.agentId || session.agent_id,
+    }));
+    return this.selectLiveBindings(this.bindings(entries), liveSessions);
+  }
+
+  previewOnly(entries) {
+    const bindings = this.bindings(entries);
+    const byRoom = new Map();
+    const bySession = new Map();
+    for (const entry of entries) {
+      const binding = bindings.get(entry.sessionId);
+      if (!binding) { bySession.set(entry.sessionId, null); continue; }
+      if (!byRoom.has(binding.matrix_room_id)) {
+        // /sessions and /history have always isolated preview failures to null.
+        try {
+          byRoom.set(binding.matrix_room_id,
+            this.previewService.readForBinding(binding).last_message_preview);
+        } catch { byRoom.set(binding.matrix_room_id, null); }
+      }
+      bySession.set(entry.sessionId, byRoom.get(binding.matrix_room_id));
+    }
+    return bySession;
+  }
+
+  decorate(entries, liveSessions, { unreadScope = "all" } = {}) {
+    if (unreadScope !== "all" && unreadScope !== "live") {
+      throw new Error(`Unsupported Session unread scope: ${unreadScope}`);
+    }
+    const bindingBySessionId = this.bindings(entries);
+    const bindings = [...bindingBySessionId.values()];
+    const liveIds = new Set(liveSessions.map((s) => s.id || s.sessionId));
+    if (unreadScope === "live") {
+      this.selectLiveBindings(bindingBySessionId, liveSessions);
+    }
+    const rooms = new Map();
+    for (const binding of bindings) {
+      if (!rooms.has(binding.matrix_room_id)) rooms.set(binding.matrix_room_id, []);
+      rooms.get(binding.matrix_room_id).push(binding);
+    }
+    const reader = this.prepareDecorationRead();
+    const resultByRoomId = new Map();
+    const unreadBySessionId = new Map();
+    // P236 R6: one synchronous read snapshot per room, not a whole-list
+    // transaction. Preview shares a raw checkpoint; each cursor stays separate.
+    const historyOnlyBindings = [];
+    for (const [roomId, roomBindings] of rooms) {
+      const hasLiveBinding = roomBindings.some((binding) =>
+        liveIds.has(binding.host_session_id)
+      );
+      // A live-only unread request still returns History previews, but History
+      // rooms have no unread cursor to keep consistent with that preview. Avoid
+      // holding an otherwise empty SQLite read transaction around those reads;
+      // the batched preview read retains fresh per-room checkpoint validation.
+      if (unreadScope === "live" && !hasLiveBinding) {
+        historyOnlyBindings.push(roomBindings[0]);
+        continue;
+      }
+      reader.withRoomRead(roomId, (readContext) => {
+        resultByRoomId.set(roomId, this.previewService.readForBinding(roomBindings[0], { readContext }));
+        for (const binding of roomBindings) {
+          if (unreadScope === "live" && !liveIds.has(binding.host_session_id)) {
+            continue;
+          }
+          unreadBySessionId.set(binding.host_session_id, reader.readUnread(binding, readContext));
+        }
+      });
+    }
+    for (const [roomId, result] of this.previewService.readForBindings(
+      historyOnlyBindings
+    )) {
+      resultByRoomId.set(roomId, result);
+    }
+    const previews = entries.map((entry) => {
+      const binding = bindingBySessionId.get(entry.sessionId);
+      if (!binding) {
+        const missing = {
+          session_id: entry.sessionId, status: "no_matrix_binding",
+          last_message_preview: null, latest_committed_seq: 0,
+          cache_status: "not_applicable", error_code: null,
+        };
+        return unreadScope === "live"
+          ? { ...missing, completed_unread_status: "not_applicable" }
+          : {
+              ...missing,
+              latest_completed_event_id: null,
+              latest_completed_stream_seq: 0,
+              read_through_stream_seq: 0,
+              has_unread_completed_message: false,
+            };
+      }
+      const result = resultByRoomId.get(binding.matrix_room_id);
+      if (unreadScope === "live" && !liveIds.has(entry.sessionId)) {
+        return {
+          session_id: entry.sessionId,
+          status: result.status,
+          last_message_preview: result.last_message_preview,
+          latest_committed_seq: result.latest_committed_seq,
+          completed_unread_status: "not_applicable",
+          cache_status: result.cache_status,
+          error_code: result.error_code,
+        };
+      }
+      const unread = unreadBySessionId.get(entry.sessionId) || {};
+      return {
+        session_id: entry.sessionId, status: result.status,
+        last_message_preview: result.last_message_preview,
+        latest_committed_seq: result.latest_committed_seq,
+        ...(unreadScope === "live" ? { completed_unread_status: "ready" } : {}),
+        latest_completed_event_id: unread.latest_completed_event_id || null,
+        latest_completed_stream_seq: Number(unread.latest_completed_stream_seq) || 0,
+        read_through_stream_seq: Number(unread.read_through_stream_seq) || 0,
+        has_unread_completed_message:
+          liveIds.has(entry.sessionId) && unread.has_unread_completed_message === true,
+        cache_status: result.cache_status, error_code: result.error_code,
+      };
+    });
+    return {
+      previews,
+      sessionRows: buildSessionSwitcherRows({
+        tagLabels: this.readTagLabels(),
+        liveSessions,
+        previewBySessionId: new Map(previews.map((preview) => [preview.session_id, preview])),
+        bindingBySessionId,
+      }),
+      uniqueRoomCount: resultByRoomId.size,
+      unreadSchemaVersion: reader.schemaVersion,
+      liveUnreadSessionCount: previews.filter((p) => p.has_unread_completed_message === true).length,
+    };
+  }
+}