@photon-ai/advanced-imessage-kit 1.11.0 → 1.11.2

package/dist/index.js

@@ -740,6 +740,8 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
     // the same message content with different GUIDs due to unstable Socket.IO connections.
     // This is especially problematic when the polling transport causes connection issues.
     __publicField(this, "processedMessages", /* @__PURE__ */ new Set());
+    // Last message timestamp for reconnect recovery
+    __publicField(this, "lastMessageTime", 0);
     // Send queue for sequential message delivery
     //
     // Purpose: Ensure all outgoing messages (text, attachments, stickers, etc.) from
@@ -750,6 +752,12 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
     // Purpose: Prevent duplicate 'ready' events when both legacy mode (no API key)
     // and auth-ok events occur, which would cause user callbacks to fire twice.
     __publicField(this, "readyEmitted", false);
+    // Flag to track if socket event listeners have been attached
+    //
+    // Purpose: Prevent duplicate event listeners when connect() is called multiple times
+    // or after close(). Without this, each connect() call would add new listeners,
+    // causing events to fire multiple times.
+    __publicField(this, "listenersAttached", false);
     this.config = {
       serverUrl: "http://localhost:1234",
       logLevel: "info",
@@ -781,8 +789,18 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
       // Only WebSocket - polling disabled to prevent message duplication
       timeout: 1e4,
       // 10 second timeout to avoid overly frequent reconnections
-      forceNew: true
+      forceNew: true,
       // Force new connection to avoid connection state pollution
+      reconnection: true,
+      // Enable auto-reconnection (default, but explicit for clarity)
+      reconnectionAttempts: Number.POSITIVE_INFINITY,
+      // Never give up
+      reconnectionDelay: 100,
+      // Start with 100ms delay (fast initial reconnect)
+      reconnectionDelayMax: 2e3,
+      // Max 2 seconds between attempts
+      randomizationFactor: 0.1
+      // Low randomization for more consistent reconnect timing
     });
     const enqueueSend = this.enqueueSend.bind(this);
     this.attachments = new AttachmentModule(this.http, enqueueSend);
@@ -822,6 +840,17 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
     return super.removeListener(event, listener);
   }
   async connect() {
+    if (!this.listenersAttached) {
+      this.listenersAttached = true;
+      this.attachSocketListeners();
+    }
+    if (this.socket.connected) {
+      this.logger.info("Already connected to iMessage server");
+      return;
+    }
+    this.socket.connect();
+  }
+  attachSocketListeners() {
     const serverEvents = [
       "new-message",
       "message-updated",
@@ -850,6 +879,9 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
               return;
             }
             this.processedMessages.add(message.guid);
+            if (message.dateCreated && message.dateCreated > this.lastMessageTime) {
+              this.lastMessageTime = message.dateCreated;
+            }
           }
         }
         if (args.length > 0) {
@@ -859,15 +891,32 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
         }
       });
     }
-    this.socket.on("disconnect", () => {
-      this.logger.info("Disconnected from iMessage server");
+    this.socket.on("disconnect", (reason) => {
+      this.logger.info(`Disconnected from iMessage server (reason: ${reason})`);
       this.readyEmitted = false;
       this.emit("disconnect");
+      if (reason === "io server disconnect") {
+        this.logger.info("Server disconnected, manually triggering reconnect...");
+        this.socket.connect();
+      }
+    });
+    this.socket.io.on("reconnect_attempt", (attempt) => {
+      this.logger.info(`Reconnection attempt #${attempt}...`);
+    });
+    this.socket.io.on("reconnect", (attempt) => {
+      this.logger.info(`Reconnected successfully after ${attempt} attempt(s)`);
     });
-    this.socket.on("auth-ok", () => {
+    this.socket.io.on("reconnect_error", (error) => {
+      this.logger.warn(`Reconnection error: ${error.message}`);
+    });
+    this.socket.io.on("reconnect_failed", () => {
+      this.logger.error("All reconnection attempts failed");
+    });
+    this.socket.on("auth-ok", async () => {
       this.logger.info("Authentication successful");
       if (!this.readyEmitted) {
         this.readyEmitted = true;
+        await this.recoverMissedMessages();
         this.emit("ready");
       }
     });
@@ -875,27 +924,51 @@ var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter {
       this.logger.error(`Authentication failed: ${error.message} ${error.reason ? `(${error.reason})` : ""}`);
       this.emit("error", new Error(`Authentication failed: ${error.message}`));
     });
-    if (this.socket.connected) {
-      this.logger.info("Already connected to iMessage server");
-      return;
-    }
-    this.socket.once("connect", () => {
+    this.socket.on("connect", async () => {
       this.logger.info("Connected to iMessage server, waiting for authentication...");
       if (!this.config.apiKey) {
         this.logger.info("No API key provided, skipping authentication (legacy server mode)");
         if (!this.readyEmitted) {
           this.readyEmitted = true;
+          await this.recoverMissedMessages();
           this.emit("ready");
         }
       }
     });
-    if (!this.socket.connected) {
-      this.socket.connect();
-    }
+    this.socket.on("connect_error", (error) => {
+      this.logger.warn(`Connection error: ${error.message}`);
+    });
   }
   async close() {
     this.socket.disconnect();
   }
+  async recoverMissedMessages() {
+    if (this.lastMessageTime <= 0) return;
+    try {
+      const after = this.lastMessageTime;
+      const messages = await this.messages.getMessages({
+        after,
+        sort: "ASC",
+        limit: 100
+      });
+      if (messages.length === 0) {
+        this.logger.debug("No missed messages to recover");
+        return;
+      }
+      this.logger.info(`Recovering ${messages.length} missed message(s)`);
+      for (const msg of messages) {
+        if (msg.guid && !this.processedMessages.has(msg.guid)) {
+          this.processedMessages.add(msg.guid);
+          if (msg.dateCreated && msg.dateCreated > this.lastMessageTime) {
+            this.lastMessageTime = msg.dateCreated;
+          }
+          super.emit("new-message", msg);
+        }
+      }
+    } catch (e) {
+      this.logger.warn(`Failed to recover missed messages: ${e}`);
+    }
+  }
   /**
    * Clear processed message records (prevent memory leaks)
    * @param maxSize Maximum number of messages to retain, default 1000