lunibee 0.1.6 → 0.1.7

package/dist/sharding/index.js

@@ -88,6 +88,22 @@ var GatewayOpcodes = {
   Hello: 10,
   HeartbeatAck: 11
 };
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
 class GatewayError extends Error {
   code;
   constructor(message, code, options) {
@@ -121,6 +137,8 @@ class Gateway {
   #rejectConnect;
   #listeners = new Map;
   #sendTimestamps = [];
+  ping = -1;
+  #decompressor;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Gateway token is required.");
@@ -141,7 +159,12 @@ class Gateway {
         browser: "Discord Android",
         device: "Discord Android"
       },
-      presence: { status: "online", activities: [], afk: false, since: null },
+      presence: {
+        status: "online",
+        activities: [],
+        afk: false,
+        since: null
+      },
       ...options
     };
     if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
@@ -156,10 +179,13 @@ class Gateway {
       return this.#connectPromise;
     this.#closed = false;
     this.#setState("CONNECT" /* Connect */);
+    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}&compress=zlib-stream` : url;
+    if (this.#options.compress)
+      this.#initDecompressor();
     this.#connectPromise = new Promise((resolve, reject) => {
       this.#resolveConnect = resolve;
       this.#rejectConnect = reject;
-      this.#open(url);
+      this.#open(connectURL);
     });
     return this.#connectPromise;
   }
@@ -195,12 +221,15 @@ class Gateway {
   send(payload) {
     if (!payload || !Number.isInteger(payload.op))
       throw new TypeError("Gateway payload must contain an integer opcode.");
+    return this.#dispatch(payload, false);
+  }
+  #dispatch(payload, privileged) {
     if (this.#ws?.readyState !== WebSocket.OPEN)
       return false;
     const now = Date.now();
     while (this.#sendTimestamps.length && now - this.#sendTimestamps[0] >= 60000)
       this.#sendTimestamps.shift();
-    if (this.#sendTimestamps.length >= 115) {
+    if (!privileged && this.#sendTimestamps.length >= 115) {
       this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
       return false;
     }
@@ -271,7 +300,11 @@ class Gateway {
     ws.addEventListener("message", (event) => {
       this.#lastMessageAt = Date.now();
       this.#zombieReported = false;
-      this.#message(ws, String(event.data));
+      if (this.#options.compress && event.data instanceof ArrayBuffer) {
+        this.#decompress(new Uint8Array(event.data)).then((text) => this.#message(ws, text)).catch((err) => this.#emitError(err));
+      } else {
+        this.#message(ws, String(event.data));
+      }
     });
     ws.addEventListener("close", (event) => this.#close(ws, event.code));
     ws.addEventListener("error", () => this.#emitError(new GatewayError("Gateway WebSocket error")));
@@ -279,7 +312,7 @@ class Gateway {
   #startZombieDetection() {
     if (this.#zombieTimer)
       clearInterval(this.#zombieTimer);
-    const interval = Math.max(1, Math.min(250, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
+    const interval = Math.max(1, Math.min(1000, this.#options.heartbeatAckTimeout, this.#options.zombieTimeout / 2));
     this.#zombieTimer = setInterval(() => {
       if (this.#closed || this.#ws?.readyState !== WebSocket.OPEN || this.#lastMessageAt === 0)
         return;
@@ -330,18 +363,24 @@ class Gateway {
         break;
       case GatewayOpcodes.HeartbeatAck:
         this.#heartbeatACK = true;
+        this.ping = Date.now() - this.#heartbeatSentAt;
         this.#clearHeartbeatAckTimer();
         this.#emit("heartbeatAck", payload.d);
         break;
       case GatewayOpcodes.Reconnect:
         ws.close(1001, "Server requested reconnect");
         break;
-      case GatewayOpcodes.InvalidSession:
-        this.#sessionId = undefined;
-        this.#sequence = null;
-        this.#emit("invalidSession", payload.d);
-        ws.close(1000, "Invalid session");
+      case GatewayOpcodes.InvalidSession: {
+        const resumable = payload.d === true;
+        if (!resumable) {
+          this.#sessionId = undefined;
+          this.#sequence = null;
+          this.#resumeURL = undefined;
+        }
+        this.#emit("invalidSession", resumable);
+        ws.close(resumable ? GatewayCloseCodes.UnknownError : 1000, resumable ? "Invalid session (resumable)" : "Invalid session");
         break;
+      }
     }
   }
   #handleDispatch(event, data) {
@@ -356,6 +395,10 @@ class Gateway {
       this.#attempt = 0;
       this.#setState("READY" /* Ready */);
       this.#emit("ready", data);
+    } else if (event === "RESUMED") {
+      this.#attempt = 0;
+      this.#setState("READY" /* Ready */);
+      this.#emit("resumed", data);
     }
     this.#emit("RAW", { event: event ?? "UNKNOWN", data });
     if (this.#closed)
@@ -433,12 +476,12 @@ class Gateway {
   #sendHeartbeat() {
     this.#heartbeatACK = false;
     this.#heartbeatSentAt = Date.now();
-    if (!this.send({
+    if (!this.#dispatch({
       op: GatewayOpcodes.Heartbeat,
       d: this.#sequence,
       s: null,
       t: null
-    })) {
+    }, true)) {
       this.#emitError(new GatewayError("Unable to send Gateway heartbeat because the WebSocket is not open."));
       return;
     }
@@ -471,14 +514,23 @@ class Gateway {
     if (action === "identify") {
       this.#sequence = null;
       this.#sessionId = undefined;
+      this.#resumeURL = undefined;
     }
     this.#setState("RECONNECT" /* Reconnect */);
     this.#scheduleReconnect();
   }
   #closeAction(code) {
-    if ([4004, 4010, 4011, 4012, 4013, 4014].includes(code))
+    const fatal = [
+      GatewayCloseCodes.AuthenticationFailed,
+      GatewayCloseCodes.InvalidShard,
+      GatewayCloseCodes.ShardingRequired,
+      GatewayCloseCodes.InvalidAPIVersion,
+      GatewayCloseCodes.InvalidIntents,
+      GatewayCloseCodes.DisallowedIntents
+    ];
+    if (fatal.includes(code))
       return "stop";
-    if ([4007, 4009].includes(code))
+    if (code === GatewayCloseCodes.InvalidSeq || code === GatewayCloseCodes.SessionTimedOut)
       return "identify";
     return this.#sessionId && this.#sequence !== null ? "resume" : "identify";
   }
@@ -491,7 +543,7 @@ class Gateway {
       return;
     }
     const delay = Math.min(this.#options.reconnectMaxDelay, this.#options.reconnectBaseDelay * 2 ** this.#attempt++);
-    const jitter = Math.random() * Math.min(250, Math.max(1, delay * 0.25));
+    const jitter = Math.random() * Math.max(1, delay * 0.25);
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = undefined;
       this.#open(this.#resumeURL ?? "wss://gateway.discord.gg/?v=10&encoding=json");
@@ -561,6 +613,37 @@ class Gateway {
     this.state = next;
     this.#emit("stateChange", { previous, next });
   }
+  #initDecompressor() {
+    const ds = new DecompressionStream("deflate-raw");
+    this.#decompressor = {
+      writer: ds.writable.getWriter(),
+      reader: ds.readable.getReader()
+    };
+  }
+  async#decompress(chunk) {
+    if (!this.#decompressor)
+      this.#initDecompressor();
+    const { writer, reader } = this.#decompressor;
+    await writer.write(chunk);
+    const parts = [];
+    while (true) {
+      const { done, value } = await Promise.race([
+        reader.read(),
+        new Promise((resolve) => setTimeout(() => resolve({ done: true, value: undefined }), 50))
+      ]);
+      if (done || !value)
+        break;
+      parts.push(value);
+    }
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+      merged.set(p, offset);
+      offset += p.length;
+    }
+    return new TextDecoder().decode(merged);
+  }
 }
 
 // packages/sharding/src/bus.ts
@@ -636,8 +719,155 @@ class ShardBus {
     }
   }
 }
+// packages/sharding/src/cluster.ts
+import { fork } from "child_process";
+import { cpus } from "os";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class ClusterManager {
+  clusters = new Map;
+  shardCount = 0;
+  #options;
+  #auto;
+  #autoScaleTimer;
+  #spawned = false;
+  constructor(options) {
+    if (!options.token?.trim())
+      throw new TypeError("A Discord bot token is required.");
+    if (!options.script?.trim())
+      throw new TypeError("A script path is required for clustering.");
+    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000)) {
+      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
+    }
+    this.#auto = options.shardCount === "auto";
+    this.#options = { ...options };
+  }
+  async fetchRecommendedShardCount() {
+    const response = await fetch("https://discord.com/api/v10/gateway/bot", {
+      headers: {
+        Authorization: `Bot ${this.#options.token}`,
+        "User-Agent": "Lunibee/0.1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Gateway discovery failed with status ${response.status}`);
+    }
+    const data = await response.json();
+    if (typeof data.shards !== "number" || !Number.isInteger(data.shards) || data.shards < 1) {
+      throw new Error("Gateway discovery returned an invalid shard count.");
+    }
+    return data.shards;
+  }
+  async spawn() {
+    if (this.#spawned)
+      return;
+    if (typeof process?.versions?.bun === "string") {
+      throw new Error("ClusterManager requires the Node.js runtime; Bun does not support child_process.fork() for this clustering mode.");
+    }
+    this.#spawned = true;
+    const count = this.#options.shardCount === "auto" || this.#options.shardCount === undefined ? await this.fetchRecommendedShardCount() : this.#options.shardCount;
+    this.shardCount = count;
+    const clusterCount = this.#options.clusterCount ?? cpus().length;
+    const chunks = Array.from({ length: clusterCount }, () => []);
+    for (let i = 0;i < count; i++) {
+      chunks[i % clusterCount].push(i);
+    }
+    for (let i = 0;i < clusterCount; i++) {
+      if (chunks[i].length === 0)
+        continue;
+      const child = fork(this.#options.script, [], {
+        env: {
+          ...process.env,
+          SHARD_LIST: chunks[i].join(","),
+          SHARD_COUNT: count.toString(),
+          CLUSTER_ID: i.toString()
+        }
+      });
+      this.clusters.set(i, {
+        id: i,
+        process: child,
+        shards: chunks[i]
+      });
+      await sleep(500);
+    }
+    if (this.#options.autoScaleInterval && this.#options.autoScaleInterval > 0) {
+      this.#autoScaleTimer = setInterval(() => {
+        this.checkAutoScale();
+      }, this.#options.autoScaleInterval);
+    }
+  }
+  async checkAutoScale() {
+    if (!this.#auto)
+      return;
+    try {
+      const recommended = await this.fetchRecommendedShardCount();
+      if (recommended !== this.shardCount) {
+        await this.respawn(recommended);
+      }
+    } catch (error) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      this.#options.onAutoScaleError?.(normalized);
+    }
+  }
+  async respawn(newShardCount) {
+    this.#options.shardCount = newShardCount;
+    await this.shutdownAll();
+    this.#spawned = false;
+    await this.spawn();
+  }
+  async shutdownAll(timeoutMs = this.#options.shutdownTimeout ?? 5000) {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
+    await Promise.all([...this.clusters.values()].map((cluster) => this.#shutdownCluster(cluster, timeoutMs)));
+    this.clusters.clear();
+    this.#spawned = false;
+  }
+  async#shutdownCluster(cluster, timeoutMs) {
+    const child = cluster.process;
+    if (child.exitCode !== null || child.signalCode !== null)
+      return;
+    await new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        if (timer)
+          clearTimeout(timer);
+        resolve();
+      };
+      child.once("exit", finish);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        child.off("exit", finish);
+        finish();
+        return;
+      }
+      timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, timeoutMs);
+    });
+  }
+  killAll() {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
+    for (const cluster of this.clusters.values()) {
+      try {
+        cluster.process.kill();
+      } catch {}
+    }
+    this.clusters.clear();
+    this.#spawned = false;
+  }
+}
 
 // packages/sharding/src/index.ts
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
 class ShardManager {
   shards = new Map;
   get shardCount() {
@@ -646,6 +876,8 @@ class ShardManager {
   #options;
   #resolved = false;
   #destroyed = false;
+  #auto;
+  #autoScaleTimer;
   constructor(options) {
     if (!options.token?.trim())
       throw new TypeError("A Discord bot token is required.");
@@ -654,6 +886,9 @@ class ShardManager {
     const count = options.shardCount === "auto" || options.shardCount === undefined ? 1 : options.shardCount;
     if (!Number.isInteger(count) || count < 1)
       throw new RangeError("Shard count must be a positive integer.");
+    if (options.autoScaleInterval !== undefined && (!Number.isInteger(options.autoScaleInterval) || options.autoScaleInterval < 1000))
+      throw new RangeError("autoScaleInterval must be an integer of at least 1000 milliseconds.");
+    this.#auto = options.shardCount === "auto";
     this.#options = { ...options };
     if (options.shardCount !== "auto")
       this.#initialize(count);
@@ -673,24 +908,56 @@ class ShardManager {
     return data.shards;
   }
   async connect() {
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
     await this.#ensureInitialized();
     for (const [id, shard] of this.shards) {
       try {
         await shard.connect();
       } catch (error) {
         this.destroy();
-        throw new Error(`Failed to connect shard ${id}.`, { cause: error });
+        throw new Error(`Failed to connect shard ${id}.`, {
+          cause: error
+        });
       }
       if (id + 1 < this.shardCount && this.#options.spawnDelay && this.#options.spawnDelay > 0)
-        await Bun.sleep(this.#options.spawnDelay);
+        await sleep2(this.#options.spawnDelay);
+    }
+    if (this.#options.autoScaleInterval && !this.#autoScaleTimer) {
+      this.#autoScaleTimer = setInterval(() => {
+        this.checkAutoScale();
+      }, this.#options.autoScaleInterval);
     }
   }
+  async checkAutoScale() {
+    if (!this.#auto)
+      return;
+    try {
+      const recommended = await this.fetchRecommendedShardCount();
+      if (recommended !== this.shardCount) {
+        await this.reshard(recommended);
+      }
+    } catch (error) {
+      this.#options.onAutoScaleError?.(error);
+    }
+  }
+  async reshard(count) {
+    this.#options.shardCount = count;
+    this.destroy();
+    await this.connect();
+  }
   destroy() {
     for (const shard of this.shards.values())
       shard.close();
     this.shards.clear();
     this.#resolved = false;
     this.#destroyed = true;
+    if (this.#autoScaleTimer) {
+      clearInterval(this.#autoScaleTimer);
+      this.#autoScaleTimer = undefined;
+    }
   }
   getShardIdForGuild(guildId) {
     const id = BigInt(guildId);
@@ -728,8 +995,9 @@ class ShardManager {
   }
 }
 export {
+  ClusterManager,
   ShardBus,
   ShardManager
 };
 
-//# debugId=155A3557E58FD4CF64756E2164756E21
+//# debugId=F2AF359ADCA0121464756E2164756E21