@agentvault/agentvault 0.19.60 → 0.19.61

package/dist/index.js

@@ -63562,7 +63562,7 @@ function migratePersistedState(raw) {
     messageHistory: []
   };
 }
-var ROOM_AGENT_TYPES, CREDENTIAL_MESSAGE_TYPES, POLL_INTERVAL_MS, RECONNECT_BASE_MS, RECONNECT_MAX_MS, PENDING_POLL_INTERVAL_MS, SecureChannel;
+var ROOM_AGENT_TYPES, CREDENTIAL_MESSAGE_TYPES, CATCHUP_MESSAGE_TYPES, POLL_INTERVAL_MS, RECONNECT_BASE_MS, RECONNECT_MAX_MS, PENDING_POLL_INTERVAL_MS, SecureChannel;
 var init_channel = __esm({
   async "src/channel.ts"() {
     "use strict";
@@ -63585,6 +63585,10 @@ var init_channel = __esm({
       "credential_revoke",
       "credential_request"
     ]);
+    CATCHUP_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+      "history_catchup_request",
+      "history_catchup_response"
+    ]);
     POLL_INTERVAL_MS = 6e3;
     RECONNECT_BASE_MS = 1e3;
     RECONNECT_MAX_MS = 3e4;
@@ -66570,6 +66574,12 @@ ${messageText}`;
             await this._persistState();
             return;
           }
+          if (CATCHUP_MESSAGE_TYPES.has(messageType)) {
+            if (messageType === "history_catchup_request") {
+              await this._handleHistoryCatchupRequest(resolvedRoomId, messageText, data.message_id);
+            }
+            return;
+          }
           if (!ROOM_AGENT_TYPES.has(messageType)) {
             return;
           }
@@ -66616,6 +66626,55 @@ ${messageText}`;
           console.error(`[SecureChannel] MLS room decrypt failed for ${resolvedRoomId.slice(0, 8)}:`, err);
         }
       }
+      /**
+       * Handle a history catch-up request from a device that just rejoined a room.
+       * Only the elected agent (smallest device_id among agents) responds.
+       */
+      async _handleHistoryCatchupRequest(roomId, requestText, messageId) {
+        let request;
+        try {
+          request = JSON.parse(requestText);
+        } catch {
+          return;
+        }
+        const roomMembers = this._persisted?.rooms?.[roomId]?.members ?? [];
+        const agentDeviceIds = roomMembers.filter((m2) => m2.entityType !== "owner" && m2.entityType !== "human").map((m2) => m2.deviceId).sort();
+        const isElected = agentDeviceIds.length > 0 && agentDeviceIds[0] === this._deviceId;
+        if (!isElected && !request.retry) {
+          console.log(
+            `[SecureChannel] History catchup: not elected (elected=${agentDeviceIds[0]?.slice(0, 8)}), ignoring`
+          );
+          return;
+        }
+        const history = this.getRoomHistory(roomId, 100);
+        let filtered = history;
+        if (request.since_ts) {
+          const sinceTime = new Date(request.since_ts).getTime();
+          filtered = history.filter((e) => new Date(e.ts).getTime() > sinceTime);
+        }
+        console.log(
+          `[SecureChannel] History catchup for room ${roomId.slice(0, 8)}: ${filtered.length} messages since ${request.since_ts || "beginning"} (total history: ${history.length})`
+        );
+        const responsePayload = JSON.stringify({
+          type: "history_catchup_response",
+          target_device_id: request.requesting_device_id,
+          messages: filtered.map((e) => ({
+            sender: e.sender,
+            sender_name: e.sender === "agent" ? this.config.agentName ?? "Agent" : "Owner",
+            text: e.text,
+            ts: e.ts
+          })),
+          no_history: filtered.length === 0
+        });
+        try {
+          await this.sendToRoom(roomId, responsePayload, { messageType: "history_catchup_response" });
+          console.log(
+            `[SecureChannel] Sent history catchup response: ${filtered.length} messages to ${request.requesting_device_id?.slice(0, 8)}`
+          );
+        } catch (sendErr) {
+          console.warn(`[SecureChannel] Failed to send history catchup response:`, sendErr);
+        }
+      }
       async _handleMlsCommit(data) {
         const groupId = data.group_id;
         for (const [roomId, room] of Object.entries(this._persisted?.rooms ?? {})) {
@@ -66830,6 +66889,71 @@ ${messageText}`;
               console.warn("[SecureChannel] Delivery ack failed:", ackErr);
             }
           }
+          for (const [roomId, mlsGroup] of this._mlsGroups) {
+            if (!mlsGroup?.isInitialized) continue;
+            if (roomId.includes(":")) continue;
+            const roomState = this._persisted?.rooms?.[roomId];
+            if (!roomState?.mlsGroupId) continue;
+            try {
+              const pendingRes = await fetch(
+                `${this.config.apiUrl}/api/v1/mls/groups/${roomState.mlsGroupId}/pending-welcomes`,
+                { headers: { Authorization: `Bearer ${this._deviceJwt}` } }
+              );
+              if (!pendingRes.ok) continue;
+              const pending = await pendingRes.json();
+              if (pending.length === 0) continue;
+              console.log(`[SecureChannel] ${pending.length} pending Welcome requests for room ${roomId.slice(0, 8)}`);
+              for (const req of pending) {
+                try {
+                  const kpRes = await fetch(
+                    `${this.config.apiUrl}/api/v1/mls/key-packages/batch?device_ids=${req.requesting_device_id}`,
+                    { headers: { Authorization: `Bearer ${this._deviceJwt}` } }
+                  );
+                  if (!kpRes.ok) continue;
+                  const kpData = await kpRes.json();
+                  const kpHex = kpData[req.requesting_device_id];
+                  if (!kpHex) continue;
+                  const kpBytes = new Uint8Array(Buffer.from(kpHex, "hex"));
+                  const memberKp = MLSGroupManager.deserializeKeyPackage(kpBytes);
+                  const { commit, welcome } = await mlsGroup.addMembers([memberKp]);
+                  if (this._ws) {
+                    this._ws.send(JSON.stringify({
+                      event: "mls_commit",
+                      data: {
+                        group_id: roomState.mlsGroupId,
+                        epoch: Number(mlsGroup.epoch),
+                        payload: Buffer.from(commit).toString("hex")
+                      }
+                    }));
+                  }
+                  if (welcome && this._ws) {
+                    this._ws.send(JSON.stringify({
+                      event: "mls_welcome",
+                      data: {
+                        target_device_id: req.requesting_device_id,
+                        group_id: roomState.mlsGroupId,
+                        room_id: roomId,
+                        payload: Buffer.from(welcome).toString("hex")
+                      }
+                    }));
+                  }
+                  await fetch(
+                    `${this.config.apiUrl}/api/v1/mls/groups/${roomState.mlsGroupId}/fulfill-welcome`,
+                    {
+                      method: "POST",
+                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
+                      body: JSON.stringify({ request_id: req.id })
+                    }
+                  );
+                  await saveMlsState(this.config.dataDir, roomState.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
+                  console.log(`[SecureChannel] Fulfilled Welcome for ${req.requesting_device_id.slice(0, 8)} in room ${roomId.slice(0, 8)}`);
+                } catch (fulfillErr) {
+                  console.warn(`[SecureChannel] Welcome fulfill failed for ${req.requesting_device_id.slice(0, 8)}:`, fulfillErr);
+                }
+              }
+            } catch {
+            }
+          }
         } catch (err) {
           console.warn("[SecureChannel] Delivery pull error:", err);
         } finally {