@agentvault/secure-channel 0.6.15 → 0.6.16

package/dist/index.js

@@ -45097,7 +45097,7 @@ function migratePersistedState(raw) {
   };
 }
 var SecureChannel = class _SecureChannel extends EventEmitter {
-  // Treat as dead if no pong within 10s
+  // 60s when idle
   constructor(config) {
     super();
     this.config = config;
@@ -45119,9 +45119,15 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
   _stopped = false;
   _persisted = null;
   _httpServer = null;
+  _pollFallbackTimer = null;
+  _syncMessageIds = null;
   static PING_INTERVAL_MS = 3e4;
   // Send ping every 30s
   static PING_TIMEOUT_MS = 1e4;
+  // Treat as dead if no pong within 10s
+  static POLL_FALLBACK_INTERVAL_MS = 3e4;
+  // 30s when messages found
+  static POLL_FALLBACK_IDLE_MS = 6e4;
   get state() {
     return this._state;
   }
@@ -45200,30 +45206,50 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
    * Each session gets the same plaintext encrypted independently.
    */
   async send(plaintext, options) {
-    if (this._state !== "ready" || this._sessions.size === 0 || !this._ws) {
+    if (this._state === "error" || this._state === "idle") {
       throw new Error("Channel is not ready");
     }
+    if (this._sessions.size === 0) {
+      throw new Error("No active sessions");
+    }
     const topicId = options?.topicId ?? this._persisted?.defaultTopicId;
     this._appendHistory("agent", plaintext, topicId);
     const messageGroupId = randomUUID();
     for (const [convId, session] of this._sessions) {
-      if (!session.activated) {
-        continue;
-      }
+      if (!session.activated) continue;
       const encrypted = session.ratchet.encrypt(plaintext);
       const transport = encryptedMessageToTransport(encrypted);
-      this._ws.send(
-        JSON.stringify({
-          event: "message",
-          data: {
-            conversation_id: convId,
-            header_blob: transport.header_blob,
-            ciphertext: transport.ciphertext,
-            message_group_id: messageGroupId,
-            topic_id: topicId
-          }
-        })
-      );
+      const msg = {
+        convId,
+        headerBlob: transport.header_blob,
+        ciphertext: transport.ciphertext,
+        messageGroupId,
+        topicId
+      };
+      if (this._state === "ready" && this._ws) {
+        this._ws.send(
+          JSON.stringify({
+            event: "message",
+            data: {
+              conversation_id: msg.convId,
+              header_blob: msg.headerBlob,
+              ciphertext: msg.ciphertext,
+              message_group_id: msg.messageGroupId,
+              topic_id: msg.topicId
+            }
+          })
+        );
+      } else {
+        if (!this._persisted.outboundQueue) {
+          this._persisted.outboundQueue = [];
+        }
+        if (this._persisted.outboundQueue.length >= 50) {
+          this._persisted.outboundQueue.shift();
+          console.warn("[SecureChannel] Outbound queue full, dropping oldest message");
+        }
+        this._persisted.outboundQueue.push(msg);
+        console.log(`[SecureChannel] Message queued (state=${this._state}, queue=${this._persisted.outboundQueue.length})`);
+      }
     }
     await this._persistState();
   }
@@ -45231,6 +45257,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
     this._stopped = true;
     this._flushAcks();
     this._stopPing();
+    this._stopPollFallback();
     this._stopHttpServer();
     if (this._ackTimer) {
       clearTimeout(this._ackTimer);
@@ -45569,6 +45596,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
       this._reconnectAttempt = 0;
       this._startPing(ws);
       await this._syncMissedMessages();
+      await this._flushOutboundQueue();
       this._setState("ready");
       this.emit("ready");
     });
@@ -45612,6 +45640,9 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
    */
   async _handleIncomingMessage(msgData) {
     if (msgData.sender_device_id === this._deviceId) return;
+    if (this._syncMessageIds?.has(msgData.message_id)) {
+      return;
+    }
     const convId = msgData.conversation_id;
     const session = this._sessions.get(convId);
     if (!session) {
@@ -45936,67 +45967,87 @@ ${messageText}`;
    * Sync missed messages across ALL sessions.
    * For each conversation, fetches messages since last sync and decrypts.
    */
+  /**
+   * Paginated sync: fetch missed messages in pages of 200, up to 5 pages (1000 messages).
+   * Tracks message IDs in _syncMessageIds to prevent duplicate processing from concurrent WS messages.
+   */
   async _syncMissedMessages() {
     if (!this._persisted?.lastMessageTimestamp || !this._deviceJwt) return;
+    this._syncMessageIds = /* @__PURE__ */ new Set();
+    const MAX_PAGES = 5;
+    const PAGE_SIZE = 200;
+    let since = this._persisted.lastMessageTimestamp;
+    let totalProcessed = 0;
     try {
-      const since = encodeURIComponent(this._persisted.lastMessageTimestamp);
-      const url = `${this.config.apiUrl}/api/v1/devices/${this._deviceId}/messages?since=${since}&limit=200`;
-      const res = await fetch(url, {
-        headers: { Authorization: `Bearer ${this._deviceJwt}` }
-      });
-      if (!res.ok) return;
-      const messages = await res.json();
-      for (const msg of messages) {
-        if (msg.sender_device_id === this._deviceId) continue;
-        const session = this._sessions.get(msg.conversation_id);
-        if (!session) {
-          console.warn(
-            `[SecureChannel] No session for conversation ${msg.conversation_id} during sync, skipping`
-          );
-          continue;
-        }
-        try {
-          const encrypted = transportToEncryptedMessage({
-            header_blob: msg.header_blob,
-            ciphertext: msg.ciphertext
-          });
-          const plaintext = session.ratchet.decrypt(encrypted);
-          this._sendAck(msg.id);
-          if (!session.activated) {
-            session.activated = true;
-            console.log(`[SecureChannel] Session ${msg.conversation_id.slice(0, 8)}... activated during sync`);
+      for (let page = 0; page < MAX_PAGES; page++) {
+        const url = `${this.config.apiUrl}/api/v1/devices/${this._deviceId}/messages?since=${encodeURIComponent(since)}&limit=${PAGE_SIZE}`;
+        const res = await fetch(url, {
+          headers: { Authorization: `Bearer ${this._deviceJwt}` }
+        });
+        if (!res.ok) break;
+        const messages = await res.json();
+        if (messages.length === 0) break;
+        for (const msg of messages) {
+          if (msg.sender_device_id === this._deviceId) continue;
+          if (this._syncMessageIds.has(msg.id)) continue;
+          this._syncMessageIds.add(msg.id);
+          const session = this._sessions.get(msg.conversation_id);
+          if (!session) {
+            console.warn(
+              `[SecureChannel] No session for conversation ${msg.conversation_id} during sync, skipping`
+            );
+            continue;
           }
-          let messageText;
-          let messageType;
           try {
-            const parsed = JSON.parse(plaintext);
-            messageType = parsed.type || "message";
-            messageText = parsed.text || plaintext;
-          } catch {
-            messageType = "message";
-            messageText = plaintext;
-          }
-          if (messageType === "message") {
-            const topicId = msg.topic_id;
-            this._appendHistory("owner", messageText, topicId);
-            const metadata = {
-              messageId: msg.id,
-              conversationId: msg.conversation_id,
-              timestamp: msg.created_at,
-              topicId
-            };
-            this.emit("message", messageText, metadata);
-            this.config.onMessage?.(messageText, metadata);
+            const encrypted = transportToEncryptedMessage({
+              header_blob: msg.header_blob,
+              ciphertext: msg.ciphertext
+            });
+            const plaintext = session.ratchet.decrypt(encrypted);
+            this._sendAck(msg.id);
+            if (!session.activated) {
+              session.activated = true;
+              console.log(`[SecureChannel] Session ${msg.conversation_id.slice(0, 8)}... activated during sync`);
+            }
+            let messageText;
+            let messageType;
+            try {
+              const parsed = JSON.parse(plaintext);
+              messageType = parsed.type || "message";
+              messageText = parsed.text || plaintext;
+            } catch {
+              messageType = "message";
+              messageText = plaintext;
+            }
+            if (messageType === "message") {
+              const topicId = msg.topic_id;
+              this._appendHistory("owner", messageText, topicId);
+              const metadata = {
+                messageId: msg.id,
+                conversationId: msg.conversation_id,
+                timestamp: msg.created_at,
+                topicId
+              };
+              this.emit("message", messageText, metadata);
+              this.config.onMessage?.(messageText, metadata);
+            }
+            this._persisted.lastMessageTimestamp = msg.created_at;
+            since = msg.created_at;
+            totalProcessed++;
+          } catch (err) {
+            this.emit("error", err);
+            break;
           }
-          this._persisted.lastMessageTimestamp = msg.created_at;
-        } catch (err) {
-          this.emit("error", err);
-          break;
         }
+        await this._persistState();
+        if (messages.length < PAGE_SIZE) break;
+      }
+      if (totalProcessed > 0) {
+        console.log(`[SecureChannel] Synced ${totalProcessed} missed messages`);
       }
-      await this._persistState();
     } catch {
     }
+    this._syncMessageIds = null;
   }
   _sendAck(messageId) {
     this._pendingAcks.push(messageId);
@@ -46008,6 +46059,36 @@ ${messageText}`;
     const batch = this._pendingAcks.splice(0, 50);
     this._ws.send(JSON.stringify({ event: "ack", data: { message_ids: batch } }));
   }
+  async _flushOutboundQueue() {
+    const queue = this._persisted?.outboundQueue;
+    if (!queue || queue.length === 0 || !this._ws) return;
+    console.log(`[SecureChannel] Flushing ${queue.length} queued outbound messages`);
+    const messages = queue.splice(0);
+    for (const msg of messages) {
+      try {
+        this._ws.send(
+          JSON.stringify({
+            event: "message",
+            data: {
+              conversation_id: msg.convId,
+              header_blob: msg.headerBlob,
+              ciphertext: msg.ciphertext,
+              message_group_id: msg.messageGroupId,
+              topic_id: msg.topicId
+            }
+          })
+        );
+      } catch (err) {
+        if (!this._persisted.outboundQueue) {
+          this._persisted.outboundQueue = [];
+        }
+        this._persisted.outboundQueue.push(msg);
+        console.warn(`[SecureChannel] Failed to flush message, re-queued: ${err}`);
+        break;
+      }
+    }
+    await this._persistState();
+  }
   _startPing(ws) {
     this._stopPing();
     this._pingTimer = setInterval(() => {
@@ -46054,6 +46135,97 @@ ${messageText}`;
     this._state = newState;
     this.emit("state", newState);
     this.config.onStateChange?.(newState);
+    if (newState === "disconnected" && !this._pollFallbackTimer && this._deviceJwt) {
+      this._startPollFallback();
+    }
+    if (newState === "ready" || newState === "error" || this._stopped) {
+      this._stopPollFallback();
+    }
+  }
+  _startPollFallback() {
+    this._stopPollFallback();
+    console.log("[SecureChannel] Starting HTTP poll fallback (WS is down)");
+    let interval = _SecureChannel.POLL_FALLBACK_INTERVAL_MS;
+    const poll = async () => {
+      if (this._state === "ready" || this._stopped) {
+        this._stopPollFallback();
+        return;
+      }
+      try {
+        const since = this._persisted?.lastMessageTimestamp;
+        if (!since || !this._deviceJwt) return;
+        const url = `${this.config.apiUrl}/api/v1/devices/${this._deviceId}/messages?since=${encodeURIComponent(since)}&limit=200`;
+        const res = await fetch(url, {
+          headers: { Authorization: `Bearer ${this._deviceJwt}` }
+        });
+        if (!res.ok) return;
+        const messages = await res.json();
+        let foundMessages = false;
+        for (const msg of messages) {
+          if (msg.sender_device_id === this._deviceId) continue;
+          const session = this._sessions.get(msg.conversation_id);
+          if (!session) continue;
+          try {
+            const encrypted = transportToEncryptedMessage({
+              header_blob: msg.header_blob,
+              ciphertext: msg.ciphertext
+            });
+            const plaintext = session.ratchet.decrypt(encrypted);
+            if (!session.activated) {
+              session.activated = true;
+            }
+            let messageText;
+            let messageType;
+            try {
+              const parsed = JSON.parse(plaintext);
+              messageType = parsed.type || "message";
+              messageText = parsed.text || plaintext;
+            } catch {
+              messageType = "message";
+              messageText = plaintext;
+            }
+            if (messageType === "message") {
+              const topicId = msg.topic_id;
+              this._appendHistory("owner", messageText, topicId);
+              const metadata = {
+                messageId: msg.id,
+                conversationId: msg.conversation_id,
+                timestamp: msg.created_at,
+                topicId
+              };
+              this.emit("message", messageText, metadata);
+              this.config.onMessage?.(messageText, metadata);
+              foundMessages = true;
+            }
+            this._persisted.lastMessageTimestamp = msg.created_at;
+          } catch (err) {
+            this.emit("error", err);
+            break;
+          }
+        }
+        if (messages.length > 0) {
+          await this._persistState();
+        }
+        const newInterval = foundMessages ? _SecureChannel.POLL_FALLBACK_INTERVAL_MS : _SecureChannel.POLL_FALLBACK_IDLE_MS;
+        if (newInterval !== interval) {
+          interval = newInterval;
+          if (this._pollFallbackTimer) {
+            clearInterval(this._pollFallbackTimer);
+            this._pollFallbackTimer = setInterval(poll, interval);
+          }
+        }
+      } catch {
+      }
+    };
+    setTimeout(poll, 1e3);
+    this._pollFallbackTimer = setInterval(poll, interval);
+  }
+  _stopPollFallback() {
+    if (this._pollFallbackTimer) {
+      clearInterval(this._pollFallbackTimer);
+      this._pollFallbackTimer = null;
+      console.log("[SecureChannel] Stopped HTTP poll fallback");
+    }
   }
   _handleError(err) {
     this._setState("error");