bbgun 0.1.0

package/dist/index.js

@@ -0,0 +1,987 @@
+import EventEmitter$1, { EventEmitter } from 'events';
+import axios from 'axios';
+import io from 'socket.io-client';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import path__default from 'path';
+import { randomUUID } from 'crypto';
+import { readFile } from 'fs/promises';
+import FormData from 'form-data';
+
+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$1 {
+  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) {
+      try {
+        const logDir = path.join(os.homedir(), "Library", "Logs", "BBGun");
+        if (!fs.existsSync(logDir)) {
+          fs.mkdirSync(logDir, { recursive: true });
+        }
+        this.logFile = path.join(logDir, "sdk.log");
+      } catch {
+      }
+    }
+  }
+  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.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 globalLogToFile = true;
+var setGlobalLogLevel = (level) => {
+  globalLogLevel = level;
+  Object.values(loggers).forEach((logger) => {
+    logger.setLogLevel(level);
+  });
+};
+var setGlobalLogToFile = (logToFile) => {
+  globalLogToFile = logToFile;
+};
+var getLogger = (tag) => {
+  let logger = loggers[tag];
+  if (!logger) {
+    logger = new Logger(tag, globalLogLevel, globalLogToFile);
+    loggers[tag] = logger;
+  }
+  return logger;
+};
+
+// 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];
+}
+function extractService(chatGuid) {
+  if (!chatGuid) return void 0;
+  const prefix = chatGuid.split(";")[0]?.toLowerCase();
+  if (prefix === "imessage") return "iMessage";
+  if (prefix === "sms") return "SMS";
+  return void 0;
+}
+async function createChatWithMessage(options) {
+  const { http, address, message, tempGuid, subject, effectId, service } = options;
+  try {
+    const response = await http.post("/api/v1/chat/new", {
+      addresses: [address],
+      message,
+      tempGuid,
+      subject,
+      effectId,
+      ...service && { service }
+    });
+    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/attachment.ts
+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/${encodeURIComponent(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/${encodeURIComponent(guid)}/download`, {
+      params,
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(response.data);
+  }
+  async downloadAttachmentLive(guid) {
+    const response = await this.http.get(`/api/v1/attachment/${encodeURIComponent(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/${encodeURIComponent(guid)}/blurhash`, {
+      params
+    });
+    const data = response.data.data;
+    return typeof data === "string" ? data : data.blurhash;
+  }
+  async ensureChatExists(chatGuid) {
+    const address = extractAddress(chatGuid);
+    if (!address) return;
+    const service = extractService(chatGuid);
+    await this.http.post("/api/v1/chat/new", {
+      addresses: [address],
+      ...service && { service }
+    });
+  }
+  async sendAttachment(options) {
+    return this.enqueueSend(async () => {
+      const fileBuffer = await readFile(options.filePath);
+      const fileName = options.fileName || path__default.basename(options.filePath);
+      const tempGuid = randomUUID();
+      const buildForm = () => {
+        const form = new FormData();
+        form.append("chatGuid", options.chatGuid);
+        form.append("attachment", fileBuffer, fileName);
+        form.append("name", fileName);
+        form.append("tempGuid", tempGuid);
+        if (options.isAudioMessage !== void 0) {
+          form.append("isAudioMessage", options.isAudioMessage.toString());
+          if (options.isAudioMessage) {
+            form.append("method", "private-api");
+          }
+        }
+        if (options.selectedMessageGuid) {
+          form.append("selectedMessageGuid", options.selectedMessageGuid);
+        }
+        return form;
+      };
+      try {
+        const form = buildForm();
+        const response = await this.http.post("/api/v1/message/attachment", form, {
+          headers: form.getHeaders()
+        });
+        return response.data.data;
+      } catch (error) {
+        if (!isChatNotExistError(error)) throw error;
+        await this.ensureChatExists(options.chatGuid);
+        const form = buildForm();
+        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__default.basename(options.filePath);
+      const fileBuffer = await readFile(options.filePath);
+      const buildForm = () => {
+        const form = new FormData();
+        form.append("attachment", fileBuffer, fileName);
+        form.append("name", fileName);
+        form.append("chatGuid", options.chatGuid);
+        form.append("isSticker", "true");
+        form.append("method", "private-api");
+        if (options.selectedMessageGuid) {
+          form.append("selectedMessageGuid", options.selectedMessageGuid);
+          form.append("partIndex", "0");
+          form.append("stickerX", String(options.stickerX ?? 0.5));
+          form.append("stickerY", String(options.stickerY ?? 0.5));
+          form.append("stickerScale", String(options.stickerScale ?? 0.75));
+          form.append("stickerRotation", String(options.stickerRotation ?? 0));
+          form.append("stickerWidth", String(options.stickerWidth ?? 300));
+        }
+        return form;
+      };
+      try {
+        const form = buildForm();
+        const { data } = await this.http.post("/api/v1/message/attachment", form, {
+          headers: form.getHeaders()
+        });
+        return data.data;
+      } catch (error) {
+        if (!isChatNotExistError(error)) throw error;
+        await this.ensureChatExists(options.chatGuid);
+        const form = buildForm();
+        const { data } = await this.http.post("/api/v1/message/attachment", form, {
+          headers: form.getHeaders()
+        });
+        return data.data;
+      }
+    });
+  }
+};
+var ChatModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getChats(options) {
+    const payload = {};
+    if (options?.offset !== void 0) payload.offset = options.offset;
+    if (options?.limit !== void 0) payload.limit = options.limit;
+    if (options?.sort) payload.sort = options.sort;
+    if (options?.withLastMessage) {
+      payload.with = ["lastmessage"];
+    }
+    const response = await this.http.post("/api/v1/chat/query", payload);
+    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/${encodeURIComponent(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/${encodeURIComponent(guid)}`, options);
+    return response.data.data;
+  }
+  async deleteChat(guid) {
+    await this.http.delete(`/api/v1/chat/${encodeURIComponent(guid)}`);
+  }
+  async markChatRead(guid) {
+    await this.http.post(`/api/v1/chat/${encodeURIComponent(guid)}/read`);
+  }
+  async markChatUnread(guid) {
+    await this.http.post(`/api/v1/chat/${encodeURIComponent(guid)}/unread`);
+  }
+  async leaveChat(guid) {
+    await this.http.post(`/api/v1/chat/${encodeURIComponent(guid)}/leave`);
+  }
+  async addParticipant(chatGuid, address) {
+    const response = await this.http.post(`/api/v1/chat/${encodeURIComponent(chatGuid)}/participant`, {
+      address
+    });
+    return response.data.data;
+  }
+  async removeParticipant(chatGuid, address) {
+    const response = await this.http.post(`/api/v1/chat/${encodeURIComponent(chatGuid)}/participant/remove`, {
+      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/${encodeURIComponent(chatGuid)}/message`, {
+      params
+    });
+    return response.data.data;
+  }
+  async setGroupIcon(chatGuid, filePath) {
+    const fileBuffer = await readFile(filePath);
+    const fileName = path__default.basename(filePath);
+    const form = new FormData();
+    form.append("icon", fileBuffer, fileName);
+    await this.http.post(`/api/v1/chat/${encodeURIComponent(chatGuid)}/icon`, form, {
+      headers: form.getHeaders()
+    });
+  }
+  async removeGroupIcon(chatGuid) {
+    await this.http.delete(`/api/v1/chat/${encodeURIComponent(chatGuid)}/icon`);
+  }
+  async getGroupIcon(chatGuid) {
+    const response = await this.http.get(`/api/v1/chat/${encodeURIComponent(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/${encodeURIComponent(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.post("/api/v1/contact/query", {
+      addresses: [address]
+    });
+    const contacts = response.data.data;
+    return contacts?.[0] ?? null;
+  }
+  async shareContactCard(chatGuid) {
+    await this.http.post(`/api/v1/chat/${encodeURIComponent(chatGuid)}/share/contact`);
+  }
+  async shouldShareContact(chatGuid) {
+    const response = await this.http.get(`/api/v1/chat/${encodeURIComponent(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 = { offset: 0 };
+    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/${encodeURIComponent(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/${encodeURIComponent(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() {
+    const response = await this.http.post("/api/v1/icloud/findmy/friends/refresh");
+    return response.data.data;
+  }
+  async getLocationForHandle(handle) {
+    const friends = await this.getFindMyFriends();
+    return friends.find((f) => f.handle === handle) ?? null;
+  }
+  async isHandleSharingLocation(handle) {
+    const location = await this.getLocationForHandle(handle);
+    return location !== null;
+  }
+};
+var SEND_TIMEOUT_MS = 5e3;
+async function withSendTimeout(promise, fallback) {
+  promise.catch(() => fallback());
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(fallback()), SEND_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+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 || randomUUID();
+      const payload = {
+        ...options,
+        tempGuid,
+        ...options.selectedMessageGuid && { method: "private-api" }
+      };
+      const doSend = async () => {
+        const response = await this.http.post("/api/v1/message/text", payload);
+        return response.data.data;
+      };
+      const fallback = () => ({ guid: tempGuid, tempGuid, text: options.message, dateCreated: Date.now() });
+      try {
+        return await withSendTimeout(doSend(), fallback);
+      } catch (error) {
+        if (!isChatNotExistError(error)) throw error;
+        const address = extractAddress(options.chatGuid);
+        if (!address) throw error;
+        const service = extractService(options.chatGuid);
+        await createChatWithMessage({
+          http: this.http,
+          address,
+          message: options.message,
+          tempGuid,
+          subject: options.subject,
+          effectId: options.effectId,
+          service
+        });
+        return fallback();
+      }
+    });
+  }
+  async getMessage(guid, options) {
+    const response = await this.http.get(`/api/v1/message/${encodeURIComponent(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 = {};
+    params.after = options?.after ?? 0;
+    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 doEdit = async () => {
+        const response = await this.http.post(
+          `/api/v1/message/${encodeURIComponent(options.messageGuid)}/edit`,
+          {
+            editedMessage: options.editedMessage,
+            backwardsCompatibilityMessage: options.backwardsCompatibilityMessage || options.editedMessage,
+            partIndex: options.partIndex ?? 0
+          }
+        );
+        return response.data.data;
+      };
+      return withSendTimeout(
+        doEdit(),
+        () => ({
+          guid: options.messageGuid,
+          text: options.editedMessage,
+          dateEdited: Date.now()
+        })
+      );
+    });
+  }
+  async sendReaction(options) {
+    return this.enqueueSend(async () => {
+      const doReact = 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;
+      };
+      return withSendTimeout(
+        doReact(),
+        () => ({
+          guid: randomUUID(),
+          associatedMessageGuid: options.messageGuid,
+          dateCreated: Date.now()
+        })
+      );
+    });
+  }
+  async unsendMessage(options) {
+    return this.enqueueSend(async () => {
+      const doUnsend = async () => {
+        const response = await this.http.post(
+          `/api/v1/message/${encodeURIComponent(options.messageGuid)}/unsend`,
+          { partIndex: options.partIndex ?? 0 }
+        );
+        return response.data.data;
+      };
+      return withSendTimeout(
+        doUnsend(),
+        () => ({
+          guid: options.messageGuid,
+          dateRetracted: Date.now()
+        })
+      );
+    });
+  }
+  async notifyMessage(guid) {
+    await this.http.post(`/api/v1/message/${encodeURIComponent(guid)}/notify`);
+  }
+  async getEmbeddedMedia(guid) {
+    const response = await this.http.get(`/api/v1/message/${encodeURIComponent(guid)}/embedded-media`);
+    return response.data.data;
+  }
+  async searchMessages(options) {
+    const { query, chatGuid, offset, limit, sort, before, after } = options;
+    if (!query || query.trim().length === 0) {
+      throw new Error("Search query cannot be empty");
+    }
+    const where = [
+      {
+        statement: "message.text LIKE :text",
+        args: { text: `%${query}%` }
+      }
+    ];
+    const payload = {
+      where
+    };
+    if (chatGuid) payload.chatGuid = chatGuid;
+    if (offset !== void 0) payload.offset = offset;
+    if (limit !== void 0) payload.limit = limit;
+    if (sort) payload.sort = sort;
+    if (before !== void 0) payload.before = before;
+    if (after !== void 0) payload.after = after;
+    const response = await this.http.post("/api/v1/message/query", payload);
+    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/${encodeURIComponent(id)}`, options);
+    return response.data.data;
+  }
+  async deleteScheduledMessage(id) {
+    await this.http.delete(`/api/v1/message/schedule/${encodeURIComponent(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 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 _BBGun = class _BBGun extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    __publicField(this, "config");
+    __publicField(this, "logger", getLogger("BBGun"));
+    __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");
+    __publicField(this, "processedMessages", /* @__PURE__ */ new Set());
+    __publicField(this, "lastMessageTime", 0);
+    __publicField(this, "sendQueue", Promise.resolve());
+    __publicField(this, "readyEmitted", false);
+    __publicField(this, "listenersAttached", false);
+    this.config = {
+      serverUrl: "http://localhost:1234",
+      logLevel: "info",
+      logToFile: true,
+      ...config
+    };
+    if (this.config.logToFile === false) {
+      setGlobalLogToFile(false);
+    }
+    if (this.config.logLevel) {
+      setGlobalLogLevel(this.config.logLevel);
+    }
+    this.http = axios.create({
+      baseURL: this.config.serverUrl,
+      params: this.config.apiKey ? { password: this.config.apiKey } : void 0
+    });
+    this.socket = io(this.config.serverUrl, {
+      query: this.config.apiKey ? { password: this.config.apiKey } : void 0,
+      transports: ["websocket"],
+      timeout: 1e4,
+      forceNew: true,
+      reconnection: true,
+      reconnectionAttempts: Number.POSITIVE_INFINITY,
+      reconnectionDelay: 100,
+      reconnectionDelayMax: 2e3,
+      randomizationFactor: 0.1
+    });
+    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 = _BBGun.getGlobalSdk();
+    if (existing) return existing;
+    const instance = new _BBGun(config);
+    _BBGun.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() {
+    if (!this.listenersAttached) {
+      this.listenersAttached = true;
+      this.attachSocketListeners();
+    }
+    if (this.socket.connected) {
+      this.logger.info("Already connected to BlueBubbles server");
+      return;
+    }
+    this.socket.connect();
+  }
+  attachSocketListeners() {
+    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 (message.dateCreated && message.dateCreated > this.lastMessageTime) {
+              this.lastMessageTime = message.dateCreated;
+            }
+          }
+        }
+        if (args.length > 0) {
+          super.emit(eventName, args[0]);
+        } else {
+          super.emit(eventName);
+        }
+      });
+    }
+    this.socket.on("disconnect", (reason) => {
+      this.logger.info(`Disconnected from BlueBubbles 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.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("connect", async () => {
+      this.logger.info("Connected to BlueBubbles server");
+      if (!this.readyEmitted) {
+        this.readyEmitted = true;
+        await this.recoverMissedMessages();
+        this.emit("ready");
+      }
+    });
+    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}`);
+    }
+  }
+  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`);
+    }
+  }
+  getProcessedMessageCount() {
+    return this.processedMessages.size;
+  }
+  enqueueSend(task) {
+    const result = this.sendQueue.then(() => task());
+    this.sendQueue = result.catch(() => {
+    });
+    return result;
+  }
+};
+__publicField(_BBGun, "getGlobalSdk", () => globalThis.__BBGun__ ?? null);
+__publicField(_BBGun, "setGlobalSdk", (sdk) => {
+  globalThis.__BBGun__ = sdk;
+});
+var BBGun = _BBGun;
+var SDK = BBGun.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";
+
+export { BBGun, CHAT_READ_STATUS_CHANGED, FT_CALL_STATUS_CHANGED, GROUP_ICON_CHANGED, GROUP_ICON_REMOVED, GROUP_NAME_CHANGE, HELLO_WORLD, IMESSAGE_ALIASES_REMOVED, INCOMING_FACETIME, MESSAGE_SEND_ERROR, MESSAGE_UPDATED, NEW_FINDMY_LOCATION, NEW_MESSAGE, NEW_SERVER, PARTICIPANT_ADDED, PARTICIPANT_LEFT, PARTICIPANT_REMOVED, SCHEDULED_MESSAGE_CREATED, SCHEDULED_MESSAGE_DELETED, SCHEDULED_MESSAGE_ERROR, SCHEDULED_MESSAGE_SENT, SCHEDULED_MESSAGE_UPDATED, SDK, SERVER_UPDATE, SERVER_UPDATE_DOWNLOADING, SERVER_UPDATE_INSTALLING, SETTINGS_BACKUP_CREATED, SETTINGS_BACKUP_DELETED, SETTINGS_BACKUP_UPDATED, THEME_BACKUP_CREATED, THEME_BACKUP_DELETED, THEME_BACKUP_UPDATED, TYPING_INDICATOR, getLogger, setGlobalLogLevel, setGlobalLogToFile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map