@stoatx/client 0.6.4 → 0.8.0

package/dist/index.cjs

@@ -33,6 +33,8 @@ __export(index_exports, {
   API: () => API,
   Attachment: () => Attachment,
   AttachmentBuilder: () => AttachmentBuilder,
+  AudioPlayer: () => AudioPlayer,
+  AudioResource: () => AudioResource,
   Base: () => Base,
   BaseChannel: () => BaseChannel,
   BitField: () => BitField,
@@ -67,7 +69,9 @@ __export(index_exports, {
   TextChannel: () => TextChannel,
   UnknownChannel: () => UnknownChannel,
   User: () => User,
-  UserManager: () => UserManager
+  UserManager: () => UserManager,
+  VoiceConnection: () => VoiceConnection,
+  VoiceManager: () => VoiceManager
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -829,6 +833,7 @@ var GatewayManager = class {
     this.client = client;
   }
   ws = null;
+  wsURL = "";
   pingInterval = null;
   token = null;
   reconnectAttempts = 0;
@@ -843,7 +848,7 @@ var GatewayManager = class {
       this.ws.removeAllListeners();
       this.ws = null;
     }
-    const baseUrl = "wss://stoat.chat/events";
+    const baseUrl = this.wsURL ?? "wss://events.stoat.chat";
     const url = `${baseUrl}?version=1&format=json&token=${this.token}`;
     this.ws = new import_ws.default(url);
     this.ws.on("open", () => {
@@ -863,6 +868,9 @@ var GatewayManager = class {
       this.client.emit("error", error);
     });
   }
+  setGatewayUrl(url) {
+    this.wsURL = url;
+  }
   handleMessage(rawData) {
     const payload = JSON.parse(rawData.toString());
     const eventType = payload.type;
@@ -1359,12 +1367,19 @@ var RESTManager = class {
       }
     }, 3e5).unref();
   }
-  baseURL = "https://stoat.chat/api";
+  baseURL = "";
+  cdnURL = "";
   token = null;
   buckets = /* @__PURE__ */ new Map();
   setToken(token) {
     this.token = token;
   }
+  setBaseURL(baseURL) {
+    this.baseURL = baseURL.replace(/\/+$/, "");
+  }
+  setCDNURL(cdnURL) {
+    this.cdnURL = cdnURL.replace(/\/+$/, "");
+  }
   /**
    * Generates a local identifier for the bucket based on method and path.
    */
@@ -1417,13 +1432,14 @@ var RESTManager = class {
       this.client.emit("debug", `Bucket [${method}:${endpoint}] exhausted. Waiting ${waitTime}ms proactively...`);
       await sleep(waitTime);
     }
+    const isBodyMethod = ["post", "patch", "put"].includes(method.toLowerCase());
     const response = await fetch(url, {
       method: method.toUpperCase(),
       headers: {
         "X-Bot-Token": this.token,
         "Content-Type": "application/json"
       },
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      ...isBodyMethod ? { body: JSON.stringify(body ?? {}) } : {}
     });
     const remainingHeader = response.headers.get("x-ratelimit-remaining");
     const resetAfterHeader = response.headers.get("x-ratelimit-reset-after");
@@ -1456,7 +1472,7 @@ var RESTManager = class {
    */
   async uploadFile(tag, fileBuffer, filename) {
     if (!this.token) throw new Error("REST_NOT_READY: No token available.");
-    const url = `https://cdn.stoatusercontent.com/${tag}`;
+    const url = `${this.cdnURL}/${tag}`;
     const formData = new FormData();
     formData.append("file", new Blob([fileBuffer]), filename);
     const response = await fetch(url, {
@@ -1959,6 +1975,9 @@ var BaseChannel = class extends Base {
   isGroup() {
     return this.type === "Group";
   }
+  isVoice() {
+    return this.isText() && this.voice !== null;
+  }
 };
 
 // src/structures/TextChannel.ts
@@ -2269,10 +2288,21 @@ var GroupChannel = class extends BaseChannel {
   }
 };
 
+// src/structures/VoiceChannel.ts
+var VoiceChannel = class extends TextChannel {
+  async join() {
+    return this.client.voice.join(this.id, this.serverId);
+  }
+  async leave() {
+    return this.client.voice.leave(this.id);
+  }
+};
+
 // src/utils/ChannelFactory.ts
 function createChannel(client, data) {
   switch (data.channel_type) {
     case "TextChannel":
+      if (data.voice) return new VoiceChannel(client, data);
       return new TextChannel(client, data);
     case "DirectMessage":
       return new DMChannel(client, data);
@@ -3852,6 +3882,50 @@ var Emoji = class extends Base {
     if (data.animated !== void 0) this.animated = data.animated;
     if (data.nsfw !== void 0) this.nsfw = data.nsfw;
   }
+  /**
+   * Fetch this emoji from the API or resolves it from the local cache.
+   * @param force Whether to skip the cache check and force a direct API request. Defaults to false.
+   * @returns A promise that resolves to the fetched {@link Emoji} object.
+   * @throws {Error} If the API request fails or if the emoji is detached.
+   * @example
+   * // Force fetch emoji to update its data
+   * await emoji.fetch(true);
+   */
+  async fetch(force) {
+    const server = this.client.servers.cache.get(this.parent.type === "Server" ? this.parent.id : "");
+    if (!server) throw new Error("No server registered in EmojiManager");
+    if (this.parent.type === "Detached") throw new Error("Cannot fetch a detached emoji");
+    return await server.emojis.fetch(this, force);
+  }
+  /**
+   * Deletes this emoji from the server.
+   * @returns A promise that resolves when the emoji has been deleted.
+   * @throws {Error} If the API request fails or if the emoji is detached.
+   * @example
+   * // Delete an emoji from the server
+   * await emoji.delete();
+   */
+  async delete() {
+    const server = this.client.servers.cache.get(this.parent.type === "Server" ? this.parent.id : "");
+    if (!server) throw new Error("No server registered in EmojiManager");
+    if (this.parent.type === "Detached") throw new Error("Emoji is already detached");
+    await server.emojis.delete(this);
+  }
+  /**
+   * Edits this emoji's properties.
+   * @param options The options to edit the emoji with.
+   * @returns A promise that resolves to the edited {@link Emoji} object.
+   * @throws {Error} If the API request fails or if the emoji is detached.
+   * @example
+   * // Edit an emoji's name
+   * await emoji.edit({ name: "new_name" });
+   */
+  async edit(options) {
+    const server = this.client.servers.cache.get(this.parent.type === "Server" ? this.parent.id : "");
+    if (!server) throw new Error("No server registered in EmojiManager");
+    if (this.parent.type === "Detached") throw new Error("Cannot edit a detached emoji");
+    return await server.emojis.edit(this, options);
+  }
 };
 
 // src/managers/EmojiManager.ts
@@ -3865,7 +3939,7 @@ var EmojiManager = class extends BaseManager {
    * Tell BaseManager how to find the ID for Emojis
    */
   extractId(data) {
-    return data._id ?? data.id;
+    return data._id;
   }
   /**
    * Tell BaseManager how to build an Emoji
@@ -3873,10 +3947,104 @@ var EmojiManager = class extends BaseManager {
   construct(data) {
     return new Emoji(this.client, data);
   }
-  async fetch(id) {
+  /**
+   * Fetch an Emoji from the API or resolves it from the local cache.
+   * @param emoji The ID, mention, or {@link Emoji} object to fetch
+   * @param force Whether to skip the cache check and force a direct API request. Defaults to false.
+   * @returns A promise that resolves to the fetched {@link Emoji} object.
+   * @throws {TypeError} If an invalid {@link EmojiResolvable} is provided.
+   * @throws {Error} If the API request fails.
+   * @example
+   * // Fetch a channel, bypassing cache
+   * const channel = await client.channels.fetch("01H...", true);
+   */
+  async fetch(emoji, force = false) {
+    if (!force) {
+      const cached = this.resolve(emoji);
+      if (cached) return cached;
+    }
+    const id = this.resolveId(emoji);
     const data = await this.client.rest.get(`/custom/emoji/${id}`);
     return this._add(data);
   }
+  /**
+   * Resolves a {@link EmojiResolvable} to a {@link Emoji} object from the cache.
+   * @param emoji The {@link EmojiResolvable} to resolve.
+   * @returns The resolved {@link Emoji} object, or undefined if not found.
+   */
+  resolve(emoji) {
+    if (emoji instanceof Emoji) return emoji;
+    if (typeof emoji === "string") {
+      const id = emoji.replace(/[<:>]/g, "");
+      return this.cache.get(id);
+    }
+    return void 0;
+  }
+  /**
+   * Extracts ID from a {@link EmojiResolvable}.
+   * @param emoji The {@link EmojiResolvable} to extract the ID from.
+   * @returns The extracted {@link Emoji} ID.
+   * @throws {TypeError} If an invalid type is provided.
+   */
+  resolveId(emoji) {
+    if (emoji instanceof Emoji) return emoji.id;
+    if (typeof emoji === "string") {
+      return emoji.replace(/:/g, "");
+    }
+    throw new Error("Invalid EmojiResolvable");
+  }
+  /**
+   * Create a new emoji
+   * @param options The options for creating the emoji
+   * @returns A promise that resolves to the created {@link Emoji} object.
+   * @throws {Error} If no server is registered in the {@link EmojiManager} or if the emoji attachment cannot be resolved.
+   * @example
+   * const emoji = await client.emojis.create(server, { emoji: "path/to/emoji.png", name: "myEmoji" });
+   */
+  async crate(options) {
+    if (!this.server) throw new Error("No server registered in EmojiManager");
+    const resolvedId = await resolveAttachment(this.client.rest, options.emoji, "emojis");
+    if (!resolvedId) throw new Error("Failed to resolve emoji attachment");
+    const payload = {
+      name: options.name,
+      parent: {
+        type: "Server",
+        id: this.server.id
+      }
+    };
+    if (options.nsfw) payload.nsfw = options.nsfw;
+    const data = await this.client.rest.put(`/custom/emoji/${resolvedId}`, payload);
+    return this._add(data);
+  }
+  /**
+   * Delete an emoji
+   * @param emoji The {@link EmojiResolvable} to delete
+   * @throws {Error} If no server is registered in the {@link EmojiManager}.
+   * @example
+   * await client.emojis.delete(emoji);
+   */
+  async delete(emoji) {
+    const id = this.resolveId(emoji);
+    await this.client.rest.delete(`/custom/emoji/${id}`);
+    this.cache.delete(id);
+  }
+  /**
+   * Edit an emoji
+   * @param emoji The {@link EmojiResolvable} to edit
+   * @param options The options to edit the emoji with
+   * @returns A promise that resolves to the edited {@link Emoji} object.
+   * @throws {Error} If no server is registered in the {@link EmojiManager}.
+   * @example
+   * const editedEmoji = await client.emojis.edit(emoji, { name: "newName" });
+   */
+  async edit(emoji, options) {
+    const id = this.resolveId(emoji);
+    const payload = {
+      name: options.name
+    };
+    const data = await this.client.rest.patch(`/custom/emoji/${id}`, payload);
+    return this._add(data);
+  }
   [util11.inspect.custom]() {
     return this.cache;
   }
@@ -4280,8 +4448,249 @@ var SweeperManager = class {
   }
 };
 
+// src/voice/VoiceConnection.ts
+var import_rtc_node = require("@livekit/rtc-node");
+var import_node_events = require("events");
+var SAMPLE_RATE = 48e3;
+var CHANNELS = 2;
+var SAMPLES_PER_FRAME = 960;
+var BYTES_PER_FRAME = SAMPLES_PER_FRAME * CHANNELS * 2;
+var VoiceConnection = class extends import_node_events.EventEmitter {
+  channelId;
+  guildId;
+  room;
+  _status = "connecting";
+  _player = null;
+  _audioSource = null;
+  _audioTrack = null;
+  constructor(channelId, guildId) {
+    super();
+    this.channelId = channelId;
+    this.guildId = guildId;
+    this.room = new import_rtc_node.Room();
+    this.room.on(import_rtc_node.RoomEvent.Disconnected, () => {
+      this._status = "disconnected";
+      this._player?.removeSubscriber(this);
+      this.emit("disconnect");
+    });
+  }
+  get status() {
+    return this._status;
+  }
+  get player() {
+    return this._player;
+  }
+  /** @internal */
+  async connect(url, token) {
+    await this.room.connect(url, token);
+    this._status = "ready";
+    this.emit("ready");
+  }
+  subscribe(player) {
+    if (this._player) this._player.removeSubscriber(this);
+    this._player = player;
+    player.addSubscriber(this);
+  }
+  unsubscribe() {
+    this._player?.removeSubscriber(this);
+    this._player = null;
+  }
+  async _feedStream(stream) {
+    if (!this._audioSource) {
+      this._audioSource = new import_rtc_node.AudioSource(SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME);
+      this._audioTrack = import_rtc_node.LocalAudioTrack.createAudioTrack("audio", this._audioSource);
+      const options = new import_rtc_node.TrackPublishOptions();
+      options.source = import_rtc_node.TrackSource.SOURCE_MICROPHONE;
+      if (!this.room.localParticipant) {
+        throw new Error("Not connected to a room");
+      }
+      await this.room.localParticipant.publishTrack(this._audioTrack, options);
+    }
+    let leftover = Buffer.alloc(0);
+    for await (const chunk of stream) {
+      const buf = Buffer.concat([leftover, chunk]);
+      let offset = 0;
+      while (offset + BYTES_PER_FRAME <= buf.length) {
+        const slice = buf.subarray(offset, offset + BYTES_PER_FRAME);
+        const tmp = slice.buffer.slice(slice.byteOffset, slice.byteOffset + slice.byteLength);
+        const pcm = new Int16Array(tmp);
+        await this._audioSource.captureFrame(new import_rtc_node.AudioFrame(pcm, SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME));
+        offset += BYTES_PER_FRAME;
+      }
+      leftover = buf.subarray(offset);
+    }
+  }
+  async disconnect() {
+    this._status = "disconnecting";
+    this.unsubscribe();
+    if (this._audioTrack) {
+      await this._audioTrack.close();
+      this._audioTrack = null;
+      this._audioSource = null;
+    }
+    await this.room.disconnect();
+  }
+};
+
+// src/voice/VoiceManager.ts
+var VoiceManager = class {
+  connections = /* @__PURE__ */ new Map();
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async join(channelId, guildId) {
+    const existing = this.connections.get(channelId);
+    if (existing?.status === "ready") return existing;
+    const { token, url } = await this.client.rest.post(`/channels/${channelId}/join_call`);
+    const connection = new VoiceConnection(channelId, guildId);
+    this.connections.set(channelId, connection);
+    connection.once("disconnect", () => this.connections.delete(channelId));
+    await connection.connect(url, token);
+    return connection;
+  }
+  get(channelId) {
+    return this.connections.get(channelId);
+  }
+  async leave(channelId) {
+    await this.connections.get(channelId)?.disconnect();
+  }
+  async leaveAll() {
+    await Promise.all([...this.connections.keys()].map((id) => this.leave(id)));
+  }
+};
+
+// src/voice/AudioPlayer.ts
+var import_node_events2 = require("events");
+var AudioPlayer = class extends import_node_events2.EventEmitter {
+  _status = "idle";
+  _resource = null;
+  /** Registered VoiceConnections subscribed to this player */
+  subscribers = /* @__PURE__ */ new Set();
+  get status() {
+    return this._status;
+  }
+  get resource() {
+    return this._resource;
+  }
+  play(resource) {
+    this.transition("buffering");
+    this._resource = resource;
+    resource.stream.once("readable", () => {
+      this.transition("playing");
+      this.feed();
+    });
+    resource.stream.once("end", () => {
+      this._resource = null;
+      this.transition("idle");
+      this.emit("idle");
+    });
+    resource.stream.once("error", (err) => {
+      this._resource = null;
+      this.transition("idle");
+      this.emit("error", err);
+    });
+  }
+  pause() {
+    if (this._status !== "playing") return;
+    this._resource?.stream.pause();
+    this.transition("paused");
+  }
+  resume() {
+    if (this._status !== "paused") return;
+    this._resource?.stream.resume();
+    this.transition("playing");
+  }
+  stop() {
+    this._resource?.stream.destroy();
+    this._resource = null;
+    this.transition("stopped");
+    this.transition("idle");
+    this.emit("idle");
+  }
+  /** @internal */
+  addSubscriber(conn) {
+    this.subscribers.add(conn);
+  }
+  /** @internal */
+  removeSubscriber(conn) {
+    this.subscribers.delete(conn);
+  }
+  feed() {
+    if (!this._resource) return;
+    for (const conn of this.subscribers) {
+      conn._feedStream(this._resource.stream);
+    }
+  }
+  transition(next) {
+    const prev = this._status;
+    this._status = next;
+    this.emit("stateChange", prev, next);
+  }
+};
+
+// src/voice/AudioResource.ts
+var import_node_stream = require("stream");
+var import_node_child_process = require("child_process");
+var import_node_stream2 = require("stream");
+var import_node_fs = require("fs");
+var AudioResource = class _AudioResource {
+  stream;
+  constructor(stream) {
+    this.stream = stream;
+  }
+  static from(source, options = {}) {
+    if (typeof source === "string" && !source.startsWith("http") && !(0, import_node_fs.existsSync)(source)) {
+      throw new Error(`Audio file not found: ${source}`);
+    }
+    const { volume = 1, inputType } = options;
+    const args = [
+      ...inputType ? ["-f", inputType] : [],
+      "-i",
+      typeof source === "string" ? source : "pipe:0",
+      "-af",
+      `volume=${volume}`,
+      "-ar",
+      "48000",
+      "-ac",
+      "2",
+      "-f",
+      "s16le",
+      "-acodec",
+      "pcm_s16le",
+      "pipe:1"
+    ];
+    const ffmpeg = (0, import_node_child_process.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "ignore"] });
+    if (source instanceof import_node_stream.Readable) {
+      source.pipe(ffmpeg.stdin);
+      source.once("error", () => ffmpeg.kill());
+    }
+    ffmpeg.stdin?.on("error", () => {
+    });
+    const pass = new import_node_stream2.PassThrough();
+    ffmpeg.stdout.pipe(pass);
+    ffmpeg.once("error", (err) => pass.destroy(err));
+    ffmpeg.once("close", (code) => {
+      if (code !== 0 && code !== null) {
+        pass.destroy(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    return new _AudioResource(pass);
+  }
+};
+
 // src/client/Client.ts
 var Client = class extends import_events2.EventEmitter {
+  rest;
+  gateway;
+  channels;
+  servers;
+  users;
+  sweepers;
+  emojis;
+  user = null;
+  options;
+  voice;
   constructor(options = {}) {
     super({ captureRejections: true });
     this.options = options;
@@ -4291,25 +4700,43 @@ var Client = class extends import_events2.EventEmitter {
     this.servers = new ServerManager(this, options.cacheLimits?.servers);
     this.users = new UserManager(this, options.cacheLimits?.users);
     this.emojis = new EmojiManager(this, void 0, options.cacheLimits?.emojis);
+    this.voice = new VoiceManager(this);
     this.sweepers = new SweeperManager(this, options.sweepers ?? {});
   }
-  rest;
-  gateway;
-  channels;
-  servers;
-  users;
-  sweepers;
-  emojis;
-  user = null;
   /**
    * Connects the bot to the Stoat Gateway
    */
   async login(token) {
     if (!token) throw new Error("A valid token must be provided.");
-    this.sweepers.start();
+    const rootApiUrl = this.options.apiURL ?? "https://api.stoat.chat";
+    this.rest.setBaseURL(rootApiUrl);
     this.rest.setToken(token);
+    const configData = await this.fetchConfig(rootApiUrl);
+    const finalWsUrl = this.options.overrides?.wsURL ?? configData.ws;
+    if (!finalWsUrl) {
+      throw new Error(
+        `[Stoat Misconfiguration] The server at '${rootApiUrl}' is running, but it has no WebSocket URL configured. The server administrator needs to set their gateway config, or you must bypass it using 'options.overrides.wsURL'.`
+      );
+    }
+    this.gateway.setGatewayUrl(finalWsUrl);
+    const finalCdnUrl = this.options.overrides?.cdnURL ?? configData.features.autumn.url;
+    if (!finalCdnUrl) {
+      throw new Error(
+        `[Stoat Misconfiguration] The server at '${rootApiUrl}' is running, but it has no CDN URL configured. The server administrator needs to set their cdn config, or you must bypass it using 'options.overrides.cdnURL'.`
+      );
+    }
+    this.rest.setCDNURL(finalCdnUrl);
+    this.sweepers.start();
     return this.gateway.connect(token);
   }
+  async fetchConfig(baseURL) {
+    try {
+      const response = await fetch(baseURL);
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Failed to fetch ${baseURL}, make sure the instance is running.`);
+    }
+  }
   [/* @__PURE__ */ Symbol.for("nodejs.rejection")](error) {
     this.emit("error", error);
   }
@@ -4369,6 +4796,8 @@ var API = __toESM(require("stoat-api"), 1);
   API,
   Attachment,
   AttachmentBuilder,
+  AudioPlayer,
+  AudioResource,
   Base,
   BaseChannel,
   BitField,
@@ -4403,6 +4832,8 @@ var API = __toESM(require("stoat-api"), 1);
   TextChannel,
   UnknownChannel,
   User,
-  UserManager
+  UserManager,
+  VoiceConnection,
+  VoiceManager
 });
 //# sourceMappingURL=index.cjs.map