@chirp-dev/chirp-sdk 1.0.2

package/dist/index.js

@@ -0,0 +1,1402 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/types.ts
+var types_exports = {};
+__export(types_exports, {
+  Collection: () => Collection,
+  DEFAULT_INTENTS: () => DEFAULT_INTENTS
+});
+var DEFAULT_INTENTS, Collection;
+var init_types = __esm({
+  "src/api/types.ts"() {
+    "use strict";
+    DEFAULT_INTENTS = [
+      "messages",
+      "messageUpdates",
+      "userStatus",
+      "typing",
+      "servers"
+    ];
+    Collection = class extends Map {
+      constructor(entries) {
+        super(entries);
+      }
+      get(key) {
+        return super.get(key);
+      }
+      set(key, value) {
+        return super.set(key, value);
+      }
+      find(predicate) {
+        for (const [key, value] of this) {
+          if (predicate(value, key)) {
+            return value;
+          }
+        }
+        return void 0;
+      }
+      filter(predicate) {
+        const result = [];
+        for (const [key, value] of this) {
+          if (predicate(value, key)) {
+            result.push(value);
+          }
+        }
+        return result;
+      }
+      first() {
+        return this.values().next().value;
+      }
+      last() {
+        let last;
+        for (const value of this.values()) {
+          last = value;
+        }
+        return last;
+      }
+    };
+  }
+});
+
+// src/client/ChirpClient.ts
+import { io } from "socket.io-client";
+
+// src/api/REST.ts
+var APIError = class extends Error {
+  statusCode;
+  code;
+  constructor(message, statusCode, code) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.code = code;
+  }
+};
+var RESTClient = class {
+  baseUrl;
+  token;
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  /**
+   * Make an authenticated API request
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Authorization": `Bot ${this.token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}`;
+      if (isJson) {
+        try {
+          const errorData = await response.json();
+          errorMessage = errorData.message || errorData.error || errorMessage;
+        } catch {
+        }
+      }
+      throw new APIError(errorMessage, response.status);
+    }
+    if (isJson && response.status !== 204) {
+      return response.json();
+    }
+    return void 0;
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint) {
+    return this.request(endpoint, { method: "GET" });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body) {
+    return this.request(endpoint, {
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  // ========================================================================
+  // Bot API Methods
+  // ========================================================================
+  /**
+   * Get the bot's user information
+   */
+  async getBotInfo() {
+    return this.get("/api/auth/me");
+  }
+  /**
+   * Get the bot's token information
+   */
+  async getTokenInfo() {
+    return this.get("/api/bot-tokens");
+  }
+  /**
+   * List all servers the bot has access to
+   */
+  async getServers() {
+    return this.get("/api/servers");
+  }
+  /**
+   * List the bot's server memberships with details
+   */
+  async getBotServers() {
+    return this.get("/api/bot-tokens/servers");
+  }
+  /**
+   * Get channels in a server
+   */
+  async getChannels(serverId) {
+    return this.get(`/api/servers/${serverId}/channels`);
+  }
+  /**
+   * Get messages in a channel
+   */
+  async getMessages(channelId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", String(options.page));
+    if (options.limit) params.append("limit", String(options.limit));
+    const query = params.toString();
+    return this.get(
+      `/api/channels/${channelId}/messages${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Send a message to a channel
+   */
+  async sendMessage(channelId, content, options = {}) {
+    return this.post(`/api/channels/${channelId}/messages`, {
+      content,
+      replyTo: options.replyTo
+    });
+  }
+  /**
+   * Reply to a specific message
+   */
+  async reply(channelId, messageId, content, author, originalContent) {
+    return this.post(`/api/channels/${channelId}/messages`, {
+      content,
+      replyTo: messageId
+    });
+  }
+  /**
+   * Edit a message (only works for bot's own messages)
+   */
+  async editMessage(messageId, content) {
+    return this.patch(`/api/messages/${messageId}`, { content });
+  }
+  /**
+   * Delete a message (only works for bot's own messages)
+   */
+  async deleteMessage(messageId) {
+    return this.delete(`/api/messages/${messageId}`);
+  }
+  /**
+   * Join a server via invite code
+   */
+  async joinServer(inviteCode) {
+    return this.post("/api/bot-tokens/servers/join", { inviteCode });
+  }
+  /**
+   * Leave a server
+   */
+  async leaveServer(serverId) {
+    return this.delete(`/api/bot-tokens/servers/${serverId}/leave`);
+  }
+};
+
+// src/client/events/EventEmitter.ts
+import EventEmitter from "eventemitter3";
+var SafeEventEmitter = class {
+  emitter;
+  constructor() {
+    this.emitter = new EventEmitter();
+  }
+  /**
+   * Register an event listener
+   */
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  /**
+   * Register a one-time event listener
+   */
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  /**
+   * Remove an event listener
+   */
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+  /**
+   * Remove all listeners for an event or all events
+   */
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
+  }
+  /**
+   * Get the count of listeners for an event
+   */
+  listenerCount(event) {
+    return this.emitter.listenerCount(event);
+  }
+};
+
+// src/commands/CommandContext.ts
+var CommandContext = class {
+  command;
+  args;
+  message;
+  channel;
+  client;
+  api;
+  constructor(command, args, message, channel, client, api) {
+    this.command = command;
+    this.args = args;
+    this.message = message;
+    this.channel = channel;
+    this.client = client;
+    this.api = api;
+  }
+  /**
+   * Reply to the command message
+   */
+  async reply(content) {
+    return this.api.sendMessage(this.channel.id, content, {
+      replyTo: this.message.id
+    });
+  }
+  /**
+   * Send a message to the same channel
+   */
+  async send(content) {
+    return this.api.sendMessage(this.channel.id, content);
+  }
+  /**
+   * Edit the bot's response message
+   */
+  async edit(messageId, content) {
+    return this.api.editMessage(messageId, content);
+  }
+  /**
+   * Delete a message
+   */
+  async delete(messageId) {
+    return this.api.deleteMessage(messageId);
+  }
+  /**
+   * Get the raw command string
+   */
+  get rawCommand() {
+    return `${this.command}${this.args.length ? " " + this.args.join(" ") : ""}`;
+  }
+};
+
+// src/commands/CommandManager.ts
+var CommandManager = class {
+  commands;
+  prefix;
+  client;
+  constructor(prefix = "/") {
+    this.commands = /* @__PURE__ */ new Map();
+    this.prefix = prefix;
+  }
+  /**
+   * Set the client reference (called by ChirpClient)
+   * @internal
+   */
+  _setClient(client) {
+    this.client = client;
+  }
+  register(commandOrBuilder) {
+    const command = "build" in commandOrBuilder ? commandOrBuilder.build() : commandOrBuilder;
+    this.commands.set(command.name, command);
+    return this;
+  }
+  /**
+   * Register multiple commands
+   */
+  registerMany(commands) {
+    for (const commandOrBuilder of commands) {
+      if ("build" in commandOrBuilder) {
+        this.register(commandOrBuilder);
+      } else {
+        this.register(commandOrBuilder);
+      }
+    }
+    return this;
+  }
+  /**
+   * Unregister a command
+   */
+  unregister(name) {
+    return this.commands.delete(name);
+  }
+  /**
+   * Get a command by name
+   */
+  get(name) {
+    return this.commands.get(name);
+  }
+  /**
+   * Check if a command exists
+   */
+  has(name) {
+    return this.commands.has(name);
+  }
+  /**
+   * Get all registered commands
+   */
+  getAll() {
+    return new Map(this.commands);
+  }
+  /**
+   * Clear all commands
+   */
+  clear() {
+    this.commands.clear();
+  }
+  /**
+   * Parse a message to check if it's a command
+   * Returns { command, args } if it's a command, null otherwise
+   */
+  parse(message) {
+    const content = message.content.trim();
+    if (!content.startsWith(this.prefix)) {
+      return null;
+    }
+    const parts = content.slice(this.prefix.length).trim().split(/\s+/);
+    const command = parts[0];
+    const args = parts.slice(1);
+    return { command, args };
+  }
+  /**
+   * Execute a command
+   * @internal
+   */
+  async execute(commandName, args, message, channel, client, api) {
+    const command = this.commands.get(commandName);
+    if (!command) {
+      return;
+    }
+    const context = new CommandContext(
+      commandName,
+      args,
+      message,
+      channel,
+      client,
+      api
+    );
+    try {
+      await command.handler(context);
+    } catch (error) {
+      if (this.client) {
+        this.client.emit("error", error);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/client/managers/ChannelManager.ts
+var ChannelManager = class {
+  api;
+  cache;
+  constructor(api) {
+    this.api = api;
+    this.cache = this.constructor.createCollection();
+  }
+  /**
+   * Create a Collection instance (avoiding circular dependency)
+   */
+  static createCollection() {
+    const { Collection: Collection2 } = (init_types(), __toCommonJS(types_exports));
+    return new Collection2();
+  }
+  /**
+   * Fetch channels for a server
+   */
+  async fetch(serverId) {
+    const channels = await this.api.getChannels(serverId);
+    for (const channel of channels) {
+      this.cache.set(channel.id, channel);
+    }
+    return channels;
+  }
+  /**
+   * Get a channel from cache by ID
+   */
+  get(channelId) {
+    return this.cache.get(channelId);
+  }
+  /**
+   * Find a channel by name in a server
+   */
+  findByName(serverId, name) {
+    return this.cache.find(
+      (channel) => channel.serverId === serverId && channel.name === name
+    );
+  }
+  /**
+   * Get all channels from cache
+   */
+  getAll() {
+    return this.cache;
+  }
+  /**
+   * Clear the channel cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Add or update a channel in cache
+   */
+  set(channel) {
+    this.cache.set(channel.id, channel);
+    return this;
+  }
+  /**
+   * Remove a channel from cache
+   */
+  delete(channelId) {
+    return this.cache.delete(channelId);
+  }
+};
+
+// src/client/managers/MessageManager.ts
+var MessageManager = class {
+  api;
+  cache;
+  constructor(api) {
+    this.api = api;
+    this.cache = this.constructor.createCollection();
+  }
+  /**
+   * Create a Collection instance (avoiding circular dependency)
+   */
+  static createCollection() {
+    const { Collection: Collection2 } = (init_types(), __toCommonJS(types_exports));
+    return new Collection2();
+  }
+  /**
+   * Fetch messages for a channel
+   */
+  async fetch(channelId, options = {}) {
+    const response = await this.api.getMessages(channelId, options);
+    for (const message of response.data) {
+      this.cache.set(message.id, message);
+    }
+    return response;
+  }
+  /**
+   * Send a message to a channel
+   */
+  async send(channelId, content, options) {
+    const message = await this.api.sendMessage(channelId, content, options);
+    this.cache.set(message.id, message);
+    return message;
+  }
+  /**
+   * Reply to a message
+   */
+  async reply(channelId, messageId, content, author, originalContent) {
+    const message = await this.api.reply(
+      channelId,
+      messageId,
+      content,
+      author,
+      originalContent
+    );
+    this.cache.set(message.id, message);
+    return message;
+  }
+  /**
+   * Edit a message
+   */
+  async edit(messageId, content) {
+    const message = await this.api.editMessage(messageId, content);
+    this.cache.set(messageId, message);
+    return message;
+  }
+  /**
+   * Delete a message
+   */
+  async delete(messageId) {
+    await this.api.deleteMessage(messageId);
+    this.cache.delete(messageId);
+  }
+  /**
+   * Get a message from cache by ID
+   */
+  get(messageId) {
+    return this.cache.get(messageId);
+  }
+  /**
+   * Get all messages from cache
+   */
+  getAll() {
+    return this.cache;
+  }
+  /**
+   * Clear the message cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Add or update a message in cache
+   */
+  set(message) {
+    this.cache.set(message.id, message);
+    return this;
+  }
+  /**
+   * Remove a message from cache
+   */
+  deleteFromCache(messageId) {
+    return this.cache.delete(messageId);
+  }
+};
+
+// src/client/managers/ServerManager.ts
+var ServerManager = class {
+  api;
+  cache;
+  constructor(api) {
+    this.api = api;
+    this.cache = this.constructor.createCollection();
+  }
+  /**
+   * Create a Collection instance (avoiding circular dependency)
+   */
+  static createCollection() {
+    const { Collection: Collection2 } = (init_types(), __toCommonJS(types_exports));
+    return new Collection2();
+  }
+  /**
+   * Fetch all servers the bot has access to
+   */
+  async fetch() {
+    const servers = await this.api.getServers();
+    for (const server of servers) {
+      this.cache.set(server.id, server);
+    }
+    return servers;
+  }
+  /**
+   * Fetch the bot's server memberships with details
+   */
+  async fetchBotServers() {
+    const botServers = await this.api.getBotServers();
+    for (const botServer of botServers) {
+      this.cache.set(botServer.serverId, {
+        id: botServer.serverId,
+        name: botServer.serverName,
+        iconUrl: botServer.serverIconUrl,
+        ownerId: "",
+        createdAt: botServer.joinedAt
+      });
+    }
+    return botServers.map((bs) => ({
+      id: bs.serverId,
+      name: bs.serverName,
+      iconUrl: bs.serverIconUrl,
+      ownerId: "",
+      createdAt: bs.joinedAt
+    }));
+  }
+  /**
+   * Join a server via invite code
+   */
+  async join(inviteCode) {
+    const server = await this.api.joinServer(inviteCode);
+    this.cache.set(server.id, server);
+    return server;
+  }
+  /**
+   * Leave a server
+   */
+  async leave(serverId) {
+    await this.api.leaveServer(serverId);
+    this.cache.delete(serverId);
+  }
+  /**
+   * Get a server from cache by ID
+   */
+  get(serverId) {
+    return this.cache.get(serverId);
+  }
+  /**
+   * Find a server by name
+   */
+  findByName(name) {
+    return this.cache.find((server) => server.name === name);
+  }
+  /**
+   * Get all servers from cache
+   */
+  getAll() {
+    return this.cache;
+  }
+  /**
+   * Clear the server cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Add or update a server in cache
+   */
+  set(server) {
+    this.cache.set(server.id, server);
+    return this;
+  }
+  /**
+   * Remove a server from cache
+   */
+  delete(serverId) {
+    return this.cache.delete(serverId);
+  }
+};
+
+// src/util/helpers.ts
+function wsToHttp(wsUrl) {
+  return wsUrl.replace(/^ws:\/\//i, "http://").replace(/^wss:\/\//i, "https://");
+}
+function httpToWs(httpUrl) {
+  return httpUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://");
+}
+function parseArgs(input) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === '"' || char === "'") {
+      inQuotes = !inQuotes;
+    } else if (char === " " && !inQuotes) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    args.push(current);
+  }
+  return args;
+}
+function formatMention(userId) {
+  return `<@${userId}>`;
+}
+function formatChannelMention(channelId) {
+  return `<#${channelId}>`;
+}
+function extractMentionIds(content) {
+  const mentionRegex = /<@([^>]+)>/g;
+  const ids = [];
+  let match;
+  while ((match = mentionRegex.exec(content)) !== null) {
+    ids.push(match[1]);
+  }
+  return ids;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    initialDelay = 1e3,
+    maxDelay = 1e4,
+    factor = 2
+  } = options;
+  let delayTime = initialDelay;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts) {
+        throw lastError;
+      }
+      await delay(delayTime);
+      delayTime = Math.min(delayTime * factor, maxDelay);
+    }
+  }
+  throw lastError;
+}
+
+// src/util/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class _Logger {
+  level;
+  prefix;
+  constructor(prefix = "ChirpSDK", level = 1 /* INFO */) {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  /**
+   * Set the log level
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Format a log message
+   */
+  format(level, message, ...args) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `[${timestamp}] [${level}] [${this.prefix}] ${message}`;
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(this.format("DEBUG", message), ...args);
+    }
+  }
+  /**
+   * Log an info message
+   */
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.info(this.format("INFO", message), ...args);
+    }
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(this.format("WARN", message), ...args);
+    }
+  }
+  /**
+   * Log an error message
+   */
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(this.format("ERROR", message), ...args);
+    }
+  }
+  /**
+   * Create a child logger with a different prefix
+   */
+  child(prefix) {
+    return new _Logger(`${this.prefix}:${prefix}`, this.level);
+  }
+};
+var logger = new Logger();
+
+// src/client/ChirpClient.ts
+var CollectionClass;
+function getCollection() {
+  if (!CollectionClass) {
+    const module = (init_types(), __toCommonJS(types_exports));
+    CollectionClass = module.Collection;
+  }
+  return CollectionClass;
+}
+var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
+  ConnectionStatus2["Disconnected"] = "disconnected";
+  ConnectionStatus2["Connecting"] = "connecting";
+  ConnectionStatus2["Connected"] = "connected";
+  ConnectionStatus2["Reconnecting"] = "reconnecting";
+  return ConnectionStatus2;
+})(ConnectionStatus || {});
+var ChirpClient = class extends SafeEventEmitter {
+  // ========================================================================
+  // Public Properties
+  // ========================================================================
+  options;
+  commands;
+  api;
+  user = null;
+  servers;
+  channels;
+  ws;
+  channelsManager;
+  messagesManager;
+  serversManager;
+  // ========================================================================
+  // Private Properties
+  // ========================================================================
+  token = null;
+  baseUrl;
+  wsUrl;
+  socket;
+  status = "disconnected" /* Disconnected */;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  log;
+  // ========================================================================
+  // Constructor
+  // ========================================================================
+  constructor(options = {}) {
+    super();
+    this.options = {
+      token: options.token ?? "",
+      baseUrl: options.baseUrl ?? "",
+      wsUrl: options.wsUrl ?? "ws://localhost:3001",
+      commandPrefix: options.commandPrefix ?? "/",
+      intents: options.intents ?? ["messages", "messageUpdates", "userStatus", "typing", "servers"],
+      reconnectAttempts: options.reconnectAttempts ?? Infinity,
+      reconnectDelay: options.reconnectDelay ?? 1e3
+    };
+    if (!this.options.baseUrl) {
+      this.baseUrl = wsToHttp(this.options.wsUrl);
+    } else {
+      this.baseUrl = this.options.baseUrl;
+    }
+    this.wsUrl = this.options.wsUrl;
+    this.log = new Logger("ChirpClient");
+    this.api = new RESTClient(this.baseUrl, "");
+    this.commands = new CommandManager(this.options.commandPrefix);
+    const Collection2 = getCollection();
+    this.servers = new Collection2();
+    this.channels = new Collection2();
+    this.setupProcessHandlers();
+  }
+  // ========================================================================
+  // Public Methods
+  // ========================================================================
+  /**
+   * Connect and authenticate the bot
+   */
+  async login(token) {
+    if (this.status !== "disconnected" /* Disconnected */) {
+      throw new Error("Client is already connected or connecting");
+    }
+    this.token = token || this.options.token;
+    if (!this.token) {
+      throw new Error("No token provided. Set token in options or pass to login()");
+    }
+    this.status = "connecting" /* Connecting */;
+    this.log.info("Connecting to", this.wsUrl);
+    try {
+      this.api = new RESTClient(this.baseUrl, this.token);
+      this.user = await this.api.getBotInfo();
+      this.log.info(`Authenticated as ${this.user.username}`);
+      this.channelsManager = new ChannelManager(this.api);
+      this.messagesManager = new MessageManager(this.api);
+      this.serversManager = new ServerManager(this.api);
+      this.commands._setClient(this);
+      await this.fetchInitialData();
+      await this.connectWebSocket();
+      this.status = "connected" /* Connected */;
+      this.emit("ready");
+      this.log.info("Bot is ready");
+    } catch (error) {
+      this.status = "disconnected" /* Disconnected */;
+      this.log.error("Login failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect the bot
+   */
+  async logout() {
+    this.clearReconnectTimer();
+    this.socket?.disconnect();
+    this.status = "disconnected" /* Disconnected */;
+    this.user = null;
+    this.log.info("Logged out");
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Check if the client is connected
+   */
+  isConnected() {
+    return this.status === "connected" /* Connected */ && this.socket?.connected === true;
+  }
+  // ========================================================================
+  // Private Methods - Initialization
+  // ========================================================================
+  async fetchInitialData() {
+    try {
+      const servers = await this.serversManager.fetch();
+      this.log.debug(`Fetched ${servers.length} servers`);
+      for (const [serverId, server] of this.serversManager.cache) {
+        this.servers.set(serverId, server);
+      }
+      for (const server of servers) {
+        try {
+          const channels = await this.channelsManager.fetch(server.id);
+          this.log.debug(`Fetched ${channels.length} channels for ${server.name}`);
+          for (const [channelId, channel] of this.channelsManager.cache) {
+            this.channels.set(channelId, channel);
+          }
+        } catch (error) {
+          this.log.warn(`Failed to fetch channels for ${server.name}:`, error);
+        }
+      }
+    } catch (error) {
+      this.log.warn("Failed to fetch initial data:", error);
+    }
+  }
+  setupProcessHandlers() {
+    const shutdown = async () => {
+      await this.logout();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+  // ========================================================================
+  // Private Methods - WebSocket Connection
+  // ========================================================================
+  async connectWebSocket() {
+    return new Promise((resolve, reject) => {
+      const socketOptions = {
+        auth: { token: `Bot ${this.token}` },
+        reconnection: false,
+        // We handle reconnection ourselves
+        transports: ["websocket"]
+      };
+      this.socket = io(this.wsUrl, socketOptions);
+      this.ws = this.socket;
+      this.socket.on("connect", () => {
+        this.log.debug("WebSocket connected");
+        this.reconnectAttempts = 0;
+        resolve();
+      });
+      this.socket.on("connect_error", (error) => {
+        this.log.error("WebSocket connection error:", error);
+        this.status = "disconnected" /* Disconnected */;
+        reject(error);
+      });
+      this.socket.on("disconnect", (reason) => {
+        this.log.warn("WebSocket disconnected:", reason);
+        this.status = "disconnected" /* Disconnected */;
+        this.emit("disconnected", reason);
+        if (reason !== "io client disconnect") {
+          this.scheduleReconnect();
+        }
+      });
+      this.setupEventHandlers();
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.options.reconnectAttempts) {
+      this.log.error("Max reconnect attempts reached");
+      this.emit("error", new Error("Max reconnect attempts reached"));
+      return;
+    }
+    this.status = "reconnecting" /* Reconnecting */;
+    this.reconnectAttempts++;
+    const delay3 = this.options.reconnectDelay * Math.min(this.reconnectAttempts, 10);
+    this.log.info(`Reconnecting in ${delay3}ms (attempt ${this.reconnectAttempts})`);
+    this.emit("reconnecting", this.reconnectAttempts);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connectWebSocket();
+        this.status = "connected" /* Connected */;
+        this.emit("reconnected", this.reconnectAttempts);
+        this.log.info("Reconnected successfully");
+      } catch (error) {
+        this.log.error("Reconnect failed:", error);
+        this.scheduleReconnect();
+      }
+    }, delay3);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // ========================================================================
+  // Private Methods - Event Handlers
+  // ========================================================================
+  setupEventHandlers() {
+    this.socket.on("message:new", this.handleMessageNew.bind(this));
+    this.socket.on("message:updated", this.handleMessageUpdated.bind(this));
+    this.socket.on("message:deleted", this.handleMessageDeleted.bind(this));
+    this.socket.on("user:status", this.handleUserStatus.bind(this));
+    this.socket.on("typing:start", this.handleTypingStart.bind(this));
+    if (this.hasIntent("polls")) {
+      this.socket.on("poll:voted", this.handlePollVoted.bind(this));
+    }
+    if (this.hasIntent("threads")) {
+      this.socket.on("thread:reopened", this.handleThreadReopened.bind(this));
+      this.socket.on("user_joined_thread", this.handleUserJoinedThread.bind(this));
+    }
+    if (this.hasIntent("voice")) {
+      this.socket.on("voice:joined", this.handleVoiceJoined.bind(this));
+      this.socket.on("voice:left", this.handleVoiceLeft.bind(this));
+    }
+    this.socket.on("bot:server_joined", this.handleBotServerJoined.bind(this));
+    this.socket.on("bot:server_left", this.handleBotServerLeft.bind(this));
+    this.socket.on("subscription:added", this.handleSubscriptionAdded.bind(this));
+  }
+  hasIntent(intent) {
+    return this.options.intents.includes(intent);
+  }
+  // ========================================================================
+  // Message Event Handlers
+  // ========================================================================
+  async handleMessageNew(data) {
+    const message = data;
+    const channelId = message.channel_id;
+    if (message.bot_id) {
+      return;
+    }
+    if (!message.content || !message.content.trim()) {
+      return;
+    }
+    this.messagesManager.set(message);
+    const channel = this.channels.get(channelId);
+    if (!channel) return;
+    const parsed = this.commands.parse(message);
+    if (parsed) {
+      try {
+        await this.commands.execute(
+          parsed.command,
+          parsed.args,
+          message,
+          channel,
+          this,
+          this.api
+        );
+      } catch (error) {
+        this.log.error(`Command execution failed for /${parsed.command}:`, error);
+      }
+      return;
+    }
+    this.emit("message:new", message, channelId);
+  }
+  handleMessageUpdated(data) {
+    const { channelId, messageId, content, edited, edited_at } = data;
+    const cachedMessage = this.messagesManager.get(messageId);
+    if (cachedMessage) {
+      const updatedMessage = {
+        ...cachedMessage,
+        content,
+        edited,
+        edited_at,
+        updated_at: edited_at
+      };
+      this.messagesManager.cache.set(messageId, updatedMessage);
+    }
+    this.emit("message:updated", messageId, channelId, data);
+  }
+  handleMessageDeleted(data) {
+    const { messageId, channelId } = data;
+    this.messagesManager.deleteFromCache(messageId);
+    this.emit("message:deleted", messageId, channelId);
+  }
+  // ========================================================================
+  // User Event Handlers
+  // ========================================================================
+  handleUserStatus(data) {
+    const { userId, status, user } = data;
+    this.emit("user:status", userId, status, user);
+  }
+  handleTypingStart(data) {
+    const { userId, channelId } = data;
+    this.emit("typing:start", userId, channelId);
+  }
+  // ========================================================================
+  // Poll Event Handlers
+  // ========================================================================
+  handlePollVoted(data) {
+    const { pollId, userId, optionId } = data;
+    this.emit("poll:voted", pollId, userId, optionId);
+  }
+  // ========================================================================
+  // Thread Event Handlers
+  // ========================================================================
+  handleThreadReopened(data) {
+    const { threadId, channelId } = data;
+    this.emit("thread:reopened", threadId, channelId);
+  }
+  handleUserJoinedThread(data) {
+    const { threadId, userId } = data;
+    this.emit("user_joined_thread", threadId, userId);
+  }
+  // ========================================================================
+  // Voice Event Handlers
+  // ========================================================================
+  handleVoiceJoined(data) {
+    const { userId, channelId, serverId } = data;
+    this.emit("voice:joined", userId, channelId, serverId);
+  }
+  handleVoiceLeft(data) {
+    const { userId, channelId, serverId } = data;
+    this.emit("voice:left", userId, channelId, serverId);
+  }
+  // ========================================================================
+  // Bot Event Handlers
+  // ========================================================================
+  handleBotServerJoined(data) {
+    const { server } = data;
+    const serverId = server.id;
+    const serverName = server.name;
+    this.log.info(`Joined server: ${serverName}`);
+    this.emit("bot:server_joined", serverId, serverName);
+    const serverInfo = {
+      id: serverId,
+      name: serverName,
+      iconUrl: server.icon_url,
+      ownerId: "",
+      // Unknown at this point
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      // Approximate
+    };
+    this.servers.set(serverId, serverInfo);
+    this.channelsManager.fetch(serverId).then((channels) => {
+      for (const [channelId, channel] of this.channelsManager.cache) {
+        this.channels.set(channelId, channel);
+      }
+    }).catch((error) => {
+      this.log.warn(`Failed to fetch channels for ${serverName}:`, error);
+    });
+  }
+  handleBotServerLeft(data) {
+    const { server } = data;
+    const serverId = server.id;
+    const serverName = server.name;
+    this.log.info(`Left server: ${serverName}`);
+    this.emit("bot:server_left", serverId, serverName);
+    this.servers.delete(serverId);
+    for (const [channelId, channel] of this.channels) {
+      if (channel.serverId === serverId) {
+        this.channels.delete(channelId);
+      }
+    }
+  }
+  // ========================================================================
+  // Subscription Event Handlers
+  // ========================================================================
+  handleSubscriptionAdded(data) {
+    this.emit("subscription:added", data);
+  }
+};
+
+// src/commands/CommandBuilder.ts
+var CommandBuilder = class {
+  name = "";
+  description = "";
+  usage;
+  handler;
+  /**
+   * Set the command name
+   */
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  /**
+   * Set the command description
+   */
+  setDescription(description) {
+    this.description = description;
+    return this;
+  }
+  /**
+   * Set the command usage example
+   */
+  setUsage(usage) {
+    this.usage = usage;
+    return this;
+  }
+  /**
+   * Set the command handler
+   */
+  setHandler(handler) {
+    this.handler = handler;
+    return this;
+  }
+  /**
+   * Build the command object
+   */
+  build() {
+    if (!this.name) {
+      throw new Error("Command name is required");
+    }
+    if (!this.description) {
+      throw new Error("Command description is required");
+    }
+    if (!this.handler) {
+      throw new Error("Command handler is required");
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      usage: this.usage,
+      handler: this.handler
+      // Cast to satisfy Command type
+    };
+  }
+};
+
+// src/errors/index.ts
+var ChirpError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChirpError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var AuthenticationError = class extends ChirpError {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends ChirpError {
+  retryAfter;
+  constructor(message, retryAfter = 0) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends ChirpError {
+  constructor(message = "Resource not found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+var PermissionError = class extends ChirpError {
+  constructor(message = "Insufficient permissions") {
+    super(message);
+    this.name = "PermissionError";
+  }
+};
+var ValidationError = class extends ChirpError {
+  constructor(message = "Validation failed") {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var ConnectionError = class extends ChirpError {
+  constructor(message = "Connection failed") {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+var CommandError = class extends ChirpError {
+  commandName;
+  constructor(message, commandName) {
+    super(message);
+    this.name = "CommandError";
+    this.commandName = commandName;
+  }
+};
+export {
+  APIError,
+  AuthenticationError,
+  ChannelManager,
+  ChirpClient,
+  ChirpError,
+  CommandBuilder,
+  CommandContext,
+  CommandError,
+  CommandManager,
+  ConnectionError,
+  ConnectionStatus,
+  LogLevel,
+  Logger,
+  MessageManager,
+  NotFoundError,
+  PermissionError,
+  RESTClient,
+  RateLimitError,
+  SafeEventEmitter,
+  ServerManager,
+  ValidationError,
+  ChirpClient as default,
+  delay,
+  extractMentionIds,
+  formatChannelMention,
+  formatMention,
+  httpToWs,
+  logger,
+  parseArgs,
+  retry,
+  wsToHttp
+};
+//# sourceMappingURL=index.js.map