@photon-ai/advanced-imessage-kit 1.1.4 → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,885 @@
+'use strict';
+
+require('reflect-metadata');
+var EventEmitter = require('events');
+var axios = require('axios');
+var io = require('socket.io-client');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var FormData = require('form-data');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var io__default = /*#__PURE__*/_interopDefault(io);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var FormData__default = /*#__PURE__*/_interopDefault(FormData);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Logger = class extends EventEmitter__default.default {
+  constructor(tag, level = "info", logToFile = true) {
+    super();
+    __publicField(this, "tag");
+    __publicField(this, "logLevel", "info");
+    __publicField(this, "logFile");
+    this.tag = tag;
+    this.logLevel = level;
+    if (logToFile) {
+      const logDir = path__namespace.join(os__namespace.homedir(), "Library", "Logs", "AdvancedIMessageKit");
+      if (!fs__namespace.existsSync(logDir)) {
+        fs__namespace.mkdirSync(logDir, { recursive: true });
+      }
+      this.logFile = path__namespace.join(logDir, "sdk.log");
+    }
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error"];
+    const currentIndex = levels.indexOf(this.logLevel);
+    const messageIndex = levels.indexOf(level);
+    return messageIndex >= currentIndex;
+  }
+  formatMessage(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `[${timestamp}][${level.toUpperCase()}][${this.tag}] ${message}`;
+  }
+  writeLog(level, message) {
+    if (!this.shouldLog(level)) return;
+    const formatted = this.formatMessage(level, message);
+    switch (level) {
+      case "error":
+        console.error(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      case "debug":
+        console.debug(formatted);
+        break;
+      default:
+        console.log(formatted);
+    }
+    if (this.logFile) {
+      try {
+        fs__namespace.appendFileSync(this.logFile, `${formatted}
+`);
+      } catch {
+      }
+    }
+    this.emit("log", { level, message, tag: this.tag });
+  }
+  info(message) {
+    this.writeLog("info", message);
+  }
+  debug(message) {
+    this.writeLog("debug", message);
+  }
+  error(message) {
+    const msg = message instanceof Error ? message.message : message;
+    this.writeLog("error", msg);
+    if (message instanceof Error && message.stack) {
+      this.writeLog("error", message.stack);
+    }
+  }
+  warn(message) {
+    this.writeLog("warn", message);
+  }
+  log(message, level = "info") {
+    this.writeLog(level, message);
+  }
+};
+
+// lib/Loggable.ts
+var loggers = {};
+var globalLogLevel = "info";
+var setGlobalLogLevel = (level) => {
+  globalLogLevel = level;
+  Object.values(loggers).forEach((logger) => {
+    logger.setLogLevel(level);
+  });
+};
+var getLogger = (tag) => {
+  let logger = loggers[tag];
+  if (!logger) {
+    logger = new Logger(tag, globalLogLevel);
+    loggers[tag] = logger;
+  }
+  return logger;
+};
+var AttachmentModule = class {
+  constructor(http, enqueueSend = (task) => task()) {
+    this.http = http;
+    this.enqueueSend = enqueueSend;
+  }
+  async getAttachmentCount() {
+    const response = await this.http.get("/api/v1/attachment/count");
+    return response.data.data.total;
+  }
+  async getAttachment(guid) {
+    const response = await this.http.get(`/api/v1/attachment/${guid}`);
+    return response.data.data;
+  }
+  async downloadAttachment(guid, options) {
+    const params = {};
+    if (options?.original !== void 0) params.original = options.original;
+    if (options?.force !== void 0) params.force = options.force;
+    if (options?.height !== void 0) params.height = options.height;
+    if (options?.width !== void 0) params.width = options.width;
+    if (options?.quality !== void 0) params.quality = options.quality;
+    const response = await this.http.get(`/api/v1/attachment/${guid}/download`, {
+      params,
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(response.data);
+  }
+  async downloadAttachmentLive(guid) {
+    const response = await this.http.get(`/api/v1/attachment/${guid}/live`, {
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(response.data);
+  }
+  async getAttachmentBlurhash(guid, options) {
+    const params = {};
+    if (options?.height !== void 0) params.height = options.height;
+    if (options?.width !== void 0) params.width = options.width;
+    if (options?.quality !== void 0) params.quality = options.quality;
+    const response = await this.http.get(`/api/v1/attachment/${guid}/blurhash`, {
+      params
+    });
+    return response.data.data.blurhash;
+  }
+  async sendAttachment(options) {
+    return this.enqueueSend(async () => {
+      const fileBuffer = await promises.readFile(options.filePath);
+      const fileName = options.fileName || path__namespace.default.basename(options.filePath);
+      const form = new FormData__default.default();
+      form.append("chatGuid", options.chatGuid);
+      form.append("attachment", fileBuffer, fileName);
+      form.append("name", fileName);
+      form.append("tempGuid", crypto.randomUUID());
+      if (options.isAudioMessage !== void 0) {
+        form.append("isAudioMessage", options.isAudioMessage.toString());
+        if (options.isAudioMessage) {
+          form.append("method", "private-api");
+        }
+      }
+      const response = await this.http.post("/api/v1/message/attachment", form, {
+        headers: form.getHeaders()
+      });
+      return response.data.data;
+    });
+  }
+  async sendSticker(options) {
+    return this.enqueueSend(async () => {
+      const fileName = options.fileName || path__namespace.default.basename(options.filePath);
+      const form = new FormData__default.default();
+      form.append("attachment", await promises.readFile(options.filePath), fileName);
+      const { data } = await this.http.post("/api/v1/attachment/upload", form, {
+        headers: form.getHeaders()
+      });
+      const response = await this.http.post("/api/v1/message/multipart", {
+        chatGuid: options.chatGuid,
+        selectedMessageGuid: options.selectedMessageGuid,
+        parts: [{ partIndex: 0, attachment: data.data.path, name: fileName }]
+      });
+      return response.data.data;
+    });
+  }
+};
+var ChatModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getChats(options) {
+    const response = await this.http.post("/api/v1/chat/query", options ?? {});
+    return response.data.data;
+  }
+  async createChat(options) {
+    const response = await this.http.post("/api/v1/chat/new", options);
+    return response.data.data;
+  }
+  async getChat(guid, options) {
+    const response = await this.http.get(`/api/v1/chat/${guid}`, {
+      params: options?.with ? { with: options.with.join(",") } : {}
+    });
+    return response.data.data;
+  }
+  async updateChat(guid, options) {
+    const response = await this.http.put(`/api/v1/chat/${guid}`, options);
+    return response.data.data;
+  }
+  async deleteChat(guid) {
+    await this.http.delete(`/api/v1/chat/${guid}`);
+  }
+  async markChatRead(guid) {
+    await this.http.post(`/api/v1/chat/${guid}/read`);
+  }
+  async markChatUnread(guid) {
+    await this.http.post(`/api/v1/chat/${guid}/unread`);
+  }
+  async leaveChat(guid) {
+    await this.http.post(`/api/v1/chat/${guid}/leave`);
+  }
+  async addParticipant(chatGuid, address) {
+    const response = await this.http.post(`/api/v1/chat/${chatGuid}/participant`, {
+      address
+    });
+    return response.data.data;
+  }
+  async removeParticipant(chatGuid, address) {
+    const response = await this.http.delete(`/api/v1/chat/${chatGuid}/participant`, {
+      data: { address }
+    });
+    return response.data.data;
+  }
+  async getChatMessages(chatGuid, options) {
+    const params = {};
+    if (options?.offset !== void 0) params.offset = options.offset;
+    if (options?.limit !== void 0) params.limit = options.limit;
+    if (options?.sort) params.sort = options.sort;
+    if (options?.before !== void 0) params.before = options.before;
+    if (options?.after !== void 0) params.after = options.after;
+    if (options?.with) params.with = options.with.join(",");
+    const response = await this.http.get(`/api/v1/chat/${chatGuid}/message`, {
+      params
+    });
+    return response.data.data;
+  }
+  async setGroupIcon(chatGuid, filePath) {
+    const fileBuffer = await promises.readFile(filePath);
+    const fileName = path__namespace.default.basename(filePath);
+    const form = new FormData__default.default();
+    form.append("icon", fileBuffer, fileName);
+    await this.http.post(`/api/v1/chat/${chatGuid}/icon`, form, {
+      headers: form.getHeaders()
+    });
+  }
+  async removeGroupIcon(chatGuid) {
+    await this.http.delete(`/api/v1/chat/${chatGuid}/icon`);
+  }
+  async getGroupIcon(chatGuid) {
+    const response = await this.http.get(`/api/v1/chat/${chatGuid}/icon`, {
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(response.data);
+  }
+  async getChatCount(options) {
+    const response = await this.http.get("/api/v1/chat/count", {
+      params: options?.includeArchived !== void 0 ? { includeArchived: options.includeArchived } : {}
+    });
+    return response.data.data;
+  }
+  async startTyping(chatGuid) {
+    await this.http.post(`/api/v1/chat/${chatGuid}/typing`);
+  }
+  async stopTyping(chatGuid) {
+    await this.http.delete(`/api/v1/chat/${chatGuid}/typing`);
+  }
+};
+
+// modules/contact.ts
+var ContactModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getContacts() {
+    const response = await this.http.get("/api/v1/contact");
+    return response.data.data;
+  }
+  async getContactCard(address) {
+    const response = await this.http.get("/api/v1/icloud/contact", {
+      params: { address }
+    });
+    return response.data.data;
+  }
+  async shareContactCard(chatGuid) {
+    await this.http.post(`/api/v1/chat/${chatGuid}/share/contact`);
+  }
+  async shouldShareContact(chatGuid) {
+    const response = await this.http.get(`/api/v1/chat/${chatGuid}/share/contact/status`);
+    return response.data.data;
+  }
+};
+
+// modules/facetime.ts
+var FaceTimeModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createFaceTimeLink() {
+    const response = await this.http.post("/api/v1/facetime/session");
+    return response.data.data;
+  }
+};
+
+// modules/handle.ts
+var HandleModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getHandleCount() {
+    const response = await this.http.get("/api/v1/handle/count");
+    return response.data.data.total;
+  }
+  async queryHandles(options) {
+    const body = {};
+    if (options?.address) body.address = options.address;
+    if (options?.with) body.with = options.with.join(",");
+    if (options?.offset !== void 0) body.offset = options.offset;
+    if (options?.limit !== void 0) body.limit = options.limit;
+    const response = await this.http.post("/api/v1/handle/query", body);
+    return {
+      data: response.data.data,
+      metadata: response.data.metadata
+    };
+  }
+  async getHandle(guid) {
+    const response = await this.http.get(`/api/v1/handle/${guid}`);
+    return response.data.data;
+  }
+  async getHandleAvailability(address, type) {
+    const response = await this.http.get(`/api/v1/handle/availability/${type}`, {
+      params: { address }
+    });
+    return response.data.data.available;
+  }
+  async getHandleFocusStatus(guid) {
+    const response = await this.http.get(`/api/v1/handle/${guid}/focus`);
+    return response.data.data.status;
+  }
+};
+
+// modules/icloud.ts
+var ICloudModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getFindMyFriends() {
+    const response = await this.http.get("/api/v1/icloud/findmy/friends");
+    return response.data.data;
+  }
+  async refreshFindMyFriends() {
+    await this.http.post("/api/v1/icloud/findmy/friends/refresh");
+  }
+};
+
+// lib/auto-create-chat.ts
+function isChatNotExistError(error) {
+  const axiosError = error;
+  const errorMsg = axiosError?.response?.data?.error?.message || axiosError?.response?.data?.message || "";
+  const lowerMsg = errorMsg.toLowerCase();
+  return lowerMsg.includes("chat does not exist") || lowerMsg.includes("chat not found");
+}
+function extractAddress(chatGuid) {
+  const parts = chatGuid.split(";-;");
+  if (parts.length !== 2 || !parts[1]) {
+    return void 0;
+  }
+  return parts[1];
+}
+async function createChatWithMessage(options) {
+  const { http, address, message, tempGuid, subject, effectId } = options;
+  try {
+    const response = await http.post("/api/v1/chat/new", {
+      addresses: [address],
+      message,
+      tempGuid,
+      subject,
+      effectId
+    });
+    return response.data.data?.guid;
+  } catch (error) {
+    throw new Error(
+      `Failed to create chat with address "${address}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// modules/message.ts
+var MessageModule = class {
+  constructor(http, enqueueSend = (task) => task()) {
+    this.http = http;
+    this.enqueueSend = enqueueSend;
+  }
+  async sendMessage(options) {
+    return this.enqueueSend(async () => {
+      const tempGuid = options.tempGuid || crypto.randomUUID();
+      const payload = { ...options, tempGuid };
+      try {
+        const response = await this.http.post("/api/v1/message/text", payload);
+        return response.data.data;
+      } catch (error) {
+        if (!isChatNotExistError(error)) throw error;
+        const address = extractAddress(options.chatGuid);
+        if (!address) throw error;
+        await createChatWithMessage({
+          http: this.http,
+          address,
+          message: options.message,
+          tempGuid,
+          subject: options.subject,
+          effectId: options.effectId
+        });
+        return { guid: tempGuid, text: options.message, dateCreated: Date.now() };
+      }
+    });
+  }
+  async getMessage(guid, options) {
+    const response = await this.http.get(`/api/v1/message/${guid}`, {
+      params: options?.with ? { with: options.with.join(",") } : {}
+    });
+    return response.data.data;
+  }
+  async getMessages(options) {
+    const response = await this.http.post("/api/v1/message/query", options ?? {});
+    return response.data.data;
+  }
+  async getMessageCount(options) {
+    const params = {};
+    if (options?.after !== void 0) params.after = options.after;
+    if (options?.before !== void 0) params.before = options.before;
+    if (options?.chatGuid) params.chatGuid = options.chatGuid;
+    if (options?.minRowId !== void 0) params.minRowId = options.minRowId;
+    if (options?.maxRowId !== void 0) params.maxRowId = options.maxRowId;
+    const response = await this.http.get("/api/v1/message/count", { params });
+    return response.data.data.total;
+  }
+  async getUpdatedMessageCount(options) {
+    const params = {};
+    if (options?.after !== void 0) params.after = options.after;
+    if (options?.before !== void 0) params.before = options.before;
+    if (options?.chatGuid) params.chatGuid = options.chatGuid;
+    if (options?.minRowId !== void 0) params.minRowId = options.minRowId;
+    if (options?.maxRowId !== void 0) params.maxRowId = options.maxRowId;
+    const response = await this.http.get("/api/v1/message/count/updated", {
+      params
+    });
+    return response.data.data.total;
+  }
+  async getSentMessageCount(options) {
+    const params = {};
+    if (options?.after !== void 0) params.after = options.after;
+    if (options?.before !== void 0) params.before = options.before;
+    if (options?.chatGuid) params.chatGuid = options.chatGuid;
+    if (options?.minRowId !== void 0) params.minRowId = options.minRowId;
+    if (options?.maxRowId !== void 0) params.maxRowId = options.maxRowId;
+    const response = await this.http.get("/api/v1/message/count/me", {
+      params
+    });
+    return response.data.data.total;
+  }
+  async editMessage(options) {
+    return this.enqueueSend(async () => {
+      const response = await this.http.post(`/api/v1/message/${options.messageGuid}/edit`, {
+        editedMessage: options.editedMessage,
+        backwardsCompatibilityMessage: options.backwardsCompatibilityMessage || options.editedMessage,
+        partIndex: options.partIndex ?? 0
+      });
+      return response.data.data;
+    });
+  }
+  async sendReaction(options) {
+    return this.enqueueSend(async () => {
+      const response = await this.http.post("/api/v1/message/react", {
+        chatGuid: options.chatGuid,
+        selectedMessageGuid: options.messageGuid,
+        reaction: options.reaction,
+        partIndex: options.partIndex ?? 0
+      });
+      return response.data.data;
+    });
+  }
+  async unsendMessage(options) {
+    return this.enqueueSend(async () => {
+      const response = await this.http.post(`/api/v1/message/${options.messageGuid}/unsend`, {
+        partIndex: options.partIndex ?? 0
+      });
+      return response.data.data;
+    });
+  }
+  async notifyMessage(guid) {
+    await this.http.post(`/api/v1/message/${guid}/notify`);
+  }
+  async getEmbeddedMedia(guid) {
+    const response = await this.http.get(`/api/v1/message/${guid}/embedded-media`);
+    return response.data.data;
+  }
+  async searchMessages(options) {
+    const response = await this.http.post("/api/v1/message/search", options);
+    return response.data.data;
+  }
+};
+
+// modules/scheduled.ts
+var ScheduledMessageModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createScheduledMessage(options) {
+    const response = await this.http.post("/api/v1/message/schedule", options);
+    return response.data.data;
+  }
+  async getScheduledMessages() {
+    const response = await this.http.get("/api/v1/message/schedule");
+    return response.data.data;
+  }
+  async updateScheduledMessage(id, options) {
+    const response = await this.http.put(`/api/v1/message/schedule/${id}`, options);
+    return response.data.data;
+  }
+  async deleteScheduledMessage(id) {
+    await this.http.delete(`/api/v1/message/schedule/${id}`);
+  }
+};
+
+// modules/server.ts
+var ServerModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getServerInfo() {
+    const response = await this.http.get("/api/v1/server/info");
+    return response.data.data;
+  }
+  async getMessageStats() {
+    const response = await this.http.get("/api/v1/server/statistics/totals");
+    return response.data.data;
+  }
+  async getServerLogs(count) {
+    const response = await this.http.get("/api/v1/server/logs", {
+      params: count !== void 0 ? { count } : {}
+    });
+    return response.data.data;
+  }
+  async getAlerts() {
+    const response = await this.http.get("/api/v1/server/alert");
+    return response.data.data;
+  }
+  async markAlertAsRead(ids) {
+    const response = await this.http.post("/api/v1/server/alert/read", { ids });
+    return response.data.data;
+  }
+  async getMediaStatistics(options) {
+    const params = {};
+    if (options?.only) params.only = options.only.join(",");
+    const response = await this.http.get("/api/v1/server/statistics/media", {
+      params
+    });
+    return response.data.data;
+  }
+  async getMediaStatisticsByChat(options) {
+    const params = {};
+    if (options?.only) params.only = options.only.join(",");
+    const response = await this.http.get("/api/v1/server/statistics/media/chat", {
+      params
+    });
+    return response.data.data;
+  }
+};
+
+// client.ts
+var _AdvancedIMessageKit = class _AdvancedIMessageKit extends EventEmitter.EventEmitter {
+  constructor(config = {}) {
+    super();
+    // Core
+    __publicField(this, "config");
+    __publicField(this, "logger", getLogger("AdvancedIMessageKit"));
+    __publicField(this, "http");
+    __publicField(this, "socket");
+    __publicField(this, "attachments");
+    __publicField(this, "messages");
+    __publicField(this, "chats");
+    __publicField(this, "contacts");
+    __publicField(this, "handles");
+    __publicField(this, "facetime");
+    __publicField(this, "icloud");
+    __publicField(this, "scheduledMessages");
+    __publicField(this, "server");
+    // Message deduplication feature
+    //
+    // Purpose: Prevent message reply loops caused by server repeatedly pushing
+    // 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());
+    // Send queue for sequential message delivery
+    //
+    // Purpose: Ensure all outgoing messages (text, attachments, stickers, etc.) from
+    // a single user/SDK instance are sent in strict order, preventing race conditions.
+    __publicField(this, "sendQueue", Promise.resolve());
+    this.config = {
+      serverUrl: "http://localhost:1234",
+      logLevel: "info",
+      ...config
+    };
+    if (this.config.logLevel) {
+      setGlobalLogLevel(this.config.logLevel);
+    }
+    this.http = axios__default.default.create({
+      baseURL: this.config.serverUrl,
+      headers: this.config.apiKey ? { "X-API-Key": this.config.apiKey } : void 0
+    });
+    this.socket = io__default.default(this.config.serverUrl, {
+      auth: this.config.apiKey ? { apiKey: this.config.apiKey } : void 0,
+      // 🚨 IMPORTANT: Polling transport configuration notes
+      //
+      // Root cause analysis:
+      // 1. Socket.IO 'polling' transport can cause unstable connections in certain network environments
+      // 2. When "xhr poll error" occurs, Socket.IO attempts to reconnect
+      // 3. During reconnection, the server may repeatedly push the same message with different GUIDs
+      // 4. This is not simple client-side duplicate processing, but server-side message duplication
+      //
+      // Solutions:
+      // - Prioritize WebSocket transport, fallback to polling as backup
+      // - Set reasonable timeout to avoid frequent reconnections
+      // - Use forceNew to ensure fresh connections and avoid state pollution
+      // - Implement client-side message deduplication as the last line of defense
+      transports: ["websocket"],
+      // Only WebSocket - polling disabled to prevent message duplication
+      timeout: 1e4,
+      // 10 second timeout to avoid overly frequent reconnections
+      forceNew: true
+      // Force new connection to avoid connection state pollution
+    });
+    const enqueueSend = this.enqueueSend.bind(this);
+    this.attachments = new AttachmentModule(this.http, enqueueSend);
+    this.messages = new MessageModule(this.http, enqueueSend);
+    this.chats = new ChatModule(this.http);
+    this.contacts = new ContactModule(this.http);
+    this.handles = new HandleModule(this.http);
+    this.facetime = new FaceTimeModule(this.http);
+    this.icloud = new ICloudModule(this.http);
+    this.scheduledMessages = new ScheduledMessageModule(this.http);
+    this.server = new ServerModule(this.http);
+  }
+  static getInstance(config) {
+    const existing = _AdvancedIMessageKit.getGlobalSdk();
+    if (existing) return existing;
+    const instance = new _AdvancedIMessageKit(config);
+    _AdvancedIMessageKit.setGlobalSdk(instance);
+    return instance;
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  addListener(event, listener) {
+    return super.addListener(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  async connect() {
+    const serverEvents = [
+      "new-message",
+      "message-updated",
+      "updated-message",
+      "chat-read-status-changed",
+      "group-name-change",
+      "participant-added",
+      "participant-removed",
+      "participant-left",
+      "group-icon-changed",
+      "group-icon-removed",
+      "message-send-error",
+      "typing-indicator",
+      "new-server",
+      "incoming-facetime",
+      "ft-call-status-changed",
+      "hello-world"
+    ];
+    for (const eventName of serverEvents) {
+      this.socket.on(eventName, (...args) => {
+        if (eventName === "new-message" && args.length > 0) {
+          const message = args[0];
+          if (message?.guid) {
+            if (this.processedMessages.has(message.guid)) {
+              this.logger.debug(`Message already processed, skipping duplicate: ${message.guid}`);
+              return;
+            }
+            this.processedMessages.add(message.guid);
+          }
+        }
+        if (args.length > 0) {
+          super.emit(eventName, args[0]);
+        } else {
+          super.emit(eventName);
+        }
+      });
+    }
+    this.socket.on("disconnect", () => {
+      this.logger.info("Disconnected from iMessage server");
+      this.emit("disconnect");
+    });
+    this.socket.on("auth-ok", () => {
+      this.logger.info("Authentication successful");
+      this.emit("ready");
+    });
+    this.socket.on("auth-error", (error) => {
+      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.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)");
+        this.emit("ready");
+      }
+    });
+    if (!this.socket.connected) {
+      this.socket.connect();
+    }
+  }
+  async close() {
+    this.socket.disconnect();
+  }
+  /**
+   * Clear processed message records (prevent memory leaks)
+   * @param maxSize Maximum number of messages to retain, default 1000
+   */
+  clearProcessedMessages(maxSize = 1e3) {
+    if (this.processedMessages.size > maxSize) {
+      const messages = Array.from(this.processedMessages);
+      this.processedMessages.clear();
+      messages.slice(-Math.floor(maxSize / 2)).forEach((guid) => {
+        this.processedMessages.add(guid);
+      });
+      this.logger.debug(`Cleared processed message records, retained ${this.processedMessages.size} messages`);
+    }
+  }
+  /**
+   * Get the count of processed messages
+   */
+  getProcessedMessageCount() {
+    return this.processedMessages.size;
+  }
+  /**
+   * Enqueue a send operation to ensure sequential delivery.
+   * All send operations (messages, attachments, stickers) should use this method
+   * to guarantee order for a single user.
+   * @param task The async send operation to enqueue
+   * @returns Promise that resolves with the task result
+   */
+  enqueueSend(task) {
+    const result = this.sendQueue.then(() => task());
+    this.sendQueue = result.catch(() => {
+    });
+    return result;
+  }
+};
+__publicField(_AdvancedIMessageKit, "getGlobalSdk", () => globalThis.__AdvancedIMessageKit__ ?? null);
+__publicField(_AdvancedIMessageKit, "setGlobalSdk", (sdk) => {
+  globalThis.__AdvancedIMessageKit__ = sdk;
+});
+var AdvancedIMessageKit = _AdvancedIMessageKit;
+var SDK = AdvancedIMessageKit.getInstance;
+
+// events.ts
+var SCHEDULED_MESSAGE_ERROR = "scheduled-message-error";
+var SCHEDULED_MESSAGE_SENT = "scheduled-message-sent";
+var SCHEDULED_MESSAGE_DELETED = "scheduled-message-deleted";
+var SCHEDULED_MESSAGE_UPDATED = "scheduled-message-updated";
+var SCHEDULED_MESSAGE_CREATED = "scheduled-message-created";
+var NEW_MESSAGE = "new-message";
+var MESSAGE_SEND_ERROR = "message-send-error";
+var MESSAGE_UPDATED = "updated-message";
+var NEW_SERVER = "new-server";
+var PARTICIPANT_REMOVED = "participant-removed";
+var PARTICIPANT_ADDED = "participant-added";
+var PARTICIPANT_LEFT = "participant-left";
+var GROUP_ICON_CHANGED = "group-icon-changed";
+var GROUP_ICON_REMOVED = "group-icon-removed";
+var CHAT_READ_STATUS_CHANGED = "chat-read-status-changed";
+var HELLO_WORLD = "hello-world";
+var TYPING_INDICATOR = "typing-indicator";
+var SERVER_UPDATE = "server-update";
+var SERVER_UPDATE_DOWNLOADING = "server-update-downloading";
+var SERVER_UPDATE_INSTALLING = "server-update-installing";
+var GROUP_NAME_CHANGE = "group-name-change";
+var INCOMING_FACETIME = "incoming-facetime";
+var SETTINGS_BACKUP_CREATED = "settings-backup-created";
+var SETTINGS_BACKUP_DELETED = "settings-backup-deleted";
+var SETTINGS_BACKUP_UPDATED = "settings-backup-updated";
+var THEME_BACKUP_CREATED = "theme-backup-created";
+var THEME_BACKUP_DELETED = "theme-backup-deleted";
+var THEME_BACKUP_UPDATED = "theme-backup-updated";
+var IMESSAGE_ALIASES_REMOVED = "imessage-aliases-removed";
+var FT_CALL_STATUS_CHANGED = "ft-call-status-changed";
+var NEW_FINDMY_LOCATION = "new-findmy-location";
+
+exports.AdvancedIMessageKit = AdvancedIMessageKit;
+exports.CHAT_READ_STATUS_CHANGED = CHAT_READ_STATUS_CHANGED;
+exports.FT_CALL_STATUS_CHANGED = FT_CALL_STATUS_CHANGED;
+exports.GROUP_ICON_CHANGED = GROUP_ICON_CHANGED;
+exports.GROUP_ICON_REMOVED = GROUP_ICON_REMOVED;
+exports.GROUP_NAME_CHANGE = GROUP_NAME_CHANGE;
+exports.HELLO_WORLD = HELLO_WORLD;
+exports.IMESSAGE_ALIASES_REMOVED = IMESSAGE_ALIASES_REMOVED;
+exports.INCOMING_FACETIME = INCOMING_FACETIME;
+exports.MESSAGE_SEND_ERROR = MESSAGE_SEND_ERROR;
+exports.MESSAGE_UPDATED = MESSAGE_UPDATED;
+exports.NEW_FINDMY_LOCATION = NEW_FINDMY_LOCATION;
+exports.NEW_MESSAGE = NEW_MESSAGE;
+exports.NEW_SERVER = NEW_SERVER;
+exports.PARTICIPANT_ADDED = PARTICIPANT_ADDED;
+exports.PARTICIPANT_LEFT = PARTICIPANT_LEFT;
+exports.PARTICIPANT_REMOVED = PARTICIPANT_REMOVED;
+exports.SCHEDULED_MESSAGE_CREATED = SCHEDULED_MESSAGE_CREATED;
+exports.SCHEDULED_MESSAGE_DELETED = SCHEDULED_MESSAGE_DELETED;
+exports.SCHEDULED_MESSAGE_ERROR = SCHEDULED_MESSAGE_ERROR;
+exports.SCHEDULED_MESSAGE_SENT = SCHEDULED_MESSAGE_SENT;
+exports.SCHEDULED_MESSAGE_UPDATED = SCHEDULED_MESSAGE_UPDATED;
+exports.SDK = SDK;
+exports.SERVER_UPDATE = SERVER_UPDATE;
+exports.SERVER_UPDATE_DOWNLOADING = SERVER_UPDATE_DOWNLOADING;
+exports.SERVER_UPDATE_INSTALLING = SERVER_UPDATE_INSTALLING;
+exports.SETTINGS_BACKUP_CREATED = SETTINGS_BACKUP_CREATED;
+exports.SETTINGS_BACKUP_DELETED = SETTINGS_BACKUP_DELETED;
+exports.SETTINGS_BACKUP_UPDATED = SETTINGS_BACKUP_UPDATED;
+exports.THEME_BACKUP_CREATED = THEME_BACKUP_CREATED;
+exports.THEME_BACKUP_DELETED = THEME_BACKUP_DELETED;
+exports.THEME_BACKUP_UPDATED = THEME_BACKUP_UPDATED;
+exports.TYPING_INDICATOR = TYPING_INDICATOR;
+exports.getLogger = getLogger;
+exports.setGlobalLogLevel = setGlobalLogLevel;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map