@anvil-js/client 0.0.1 → 0.0.3

package/dist/ws/index.cjs

@@ -0,0 +1,589 @@
+'use strict';
+
+var uuid = require('uuid');
+
+// src/ws/codec.ts
+var ConnectionCodec = class {
+  /** typeId → packetName (frames we receive) */
+  incoming = /* @__PURE__ */ new Map();
+  /** packetName → typeId (frames we send) */
+  outgoing = /* @__PURE__ */ new Map();
+  nextOutgoingTypeId = 100;
+  constructor() {
+    this.incoming.set(0, "connection.ConnectionRegisterPacketTypeIdPacket");
+    this.outgoing.set("connection.ConnectionRegisterPacketTypeIdPacket", 0);
+  }
+  /**
+   * Decode a single binary frame. Returns null for registration
+   * frames (which mutate the codec in place) and for unknown
+   * typeIds.
+   */
+  decode(buffer) {
+    const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    if (view.byteLength < 4) return null;
+    const dv = new DataView(view.buffer, view.byteOffset, view.byteLength);
+    let off = 0;
+    const typeId = dv.getInt32(off);
+    off += 4;
+    const name = this.incoming.get(typeId);
+    if (!name) return null;
+    const idLen = dv.getInt32(off);
+    off += 4;
+    const id = new TextDecoder("utf-8").decode(view.subarray(off, off + idLen));
+    off += idLen;
+    const payloadLen = dv.getInt32(off);
+    off += 4;
+    const payloadJson = new TextDecoder("utf-8").decode(view.subarray(off, off + payloadLen));
+    if (name === "connection.ConnectionRegisterPacketTypeIdPacket") {
+      const reg = JSON.parse(payloadJson);
+      this.incoming.set(reg.b, reg.a);
+      return null;
+    }
+    return { type: name, id, payload: JSON.parse(payloadJson) };
+  }
+  /**
+   * Encode a packet to a binary frame. If the packet name has
+   * not been registered yet, a fresh typeId is allocated and
+   * a registration frame is yielded first.
+   */
+  encode(name, payload, id = uuid.v4()) {
+    const frames = [];
+    if (!this.outgoing.has(name)) {
+      this.outgoing.set(name, this.nextOutgoingTypeId++);
+      frames.push(
+        ...this.encode(
+          "connection.ConnectionRegisterPacketTypeIdPacket",
+          { a: name, b: this.outgoing.get(name) },
+          ""
+        )
+      );
+    }
+    const typeId = this.outgoing.get(name);
+    const payloadBytes = new TextEncoder().encode(JSON.stringify(payload));
+    const idBytes = id ? new TextEncoder().encode(id) : new Uint8Array(0);
+    const total = 4 + 4 + idBytes.length + 4 + payloadBytes.length;
+    const buf = new Uint8Array(total);
+    const dv = new DataView(buf.buffer);
+    let off = 0;
+    dv.setInt32(off, typeId);
+    off += 4;
+    dv.setInt32(off, idBytes.length);
+    off += 4;
+    buf.set(idBytes, off);
+    off += idBytes.length;
+    dv.setInt32(off, payloadBytes.length);
+    off += 4;
+    buf.set(payloadBytes, off);
+    frames.push(buf);
+    return frames;
+  }
+  /** Register a packet type up-front (returns the typeId assigned). */
+  registerOutgoing(name) {
+    if (!this.outgoing.has(name)) {
+      this.outgoing.set(name, this.nextOutgoingTypeId++);
+    }
+    return this.outgoing.get(name);
+  }
+};
+
+// src/ws/client.ts
+var AnvilWsClient = class {
+  ws = null;
+  codec = new ConnectionCodec();
+  config;
+  listeners = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  state = "disconnected";
+  bootstrapReceived = false;
+  reconnectTimer = null;
+  defaultRequestTimeoutMs = 1e4;
+  constructor(config) {
+    this.config = {
+      maxProtocolVersion: 9,
+      autoReconnect: true,
+      reconnectDelayMs: 2e3,
+      authenticationToken: "",
+      ...config
+    };
+  }
+  // ----- Lifecycle -----
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.state === "ready" || this.state === "connected") {
+        resolve();
+        return;
+      }
+      this.state = "connecting";
+      const params = new URLSearchParams();
+      params.set("essential-user-uuid", this.config.userUuid);
+      params.set("essential-user-name", this.config.userName);
+      params.set("essential-max-protocol-version", String(this.config.maxProtocolVersion));
+      if (this.config.authenticationToken) {
+        params.set("essential-authentication-token", this.config.authenticationToken);
+      }
+      const url = `${this.config.url}?${params.toString()}`;
+      this.ws = new WebSocket(url);
+      this.ws.binaryType = "arraybuffer";
+      this.ws.onopen = () => {
+        this.state = "connected";
+        this.emit("open", void 0);
+        this.preRegisterOutgoing();
+        resolve();
+      };
+      this.ws.onerror = (e) => {
+        this.emit("error", new Error("WebSocket error"));
+        reject(new Error("WebSocket error"));
+      };
+      this.ws.onclose = (ev) => {
+        this.state = "disconnected";
+        this.emit("close", { code: ev.code, reason: ev.reason });
+        for (const [, req] of this.pendingRequests) {
+          clearTimeout(req.timer);
+          req.reject(new Error("Connection closed"));
+        }
+        this.pendingRequests.clear();
+        if (this.config.autoReconnect && this.bootstrapReceived) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onmessage = (ev) => {
+        this.handleFrame(ev.data);
+      };
+    });
+  }
+  disconnect() {
+    this.config.autoReconnect = false;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().catch(() => {
+      });
+    }, this.config.reconnectDelayMs);
+  }
+  preRegisterOutgoing() {
+    const TYPES = [
+      "chat.ClientChatChannelMessageCreatePacket",
+      "chat.ClientChatChannelMessagesRetrievePacket",
+      "chat.ClientChatChannelCreatePacket",
+      "chat.ClientChatChannelMessageUpdatePacket",
+      "chat.ChatChannelMessageDeletePacket",
+      "chat.ClientChatChannelMessageReportPacket",
+      "chat.ChatChannelMemberAddPacket",
+      "chat.ChatChannelMemberRemovePacket",
+      "chat.ClientChatChannelMutePacket",
+      "chat.ClientChatChannelReadStatePacket",
+      "chat.ClientChatChannelMessageReadStatePacket",
+      "relationships.ClientRelationshipCreatePacket",
+      "relationships.RelationshipDeletePacket",
+      "relationships.ClientLookupUuidByNamePacket",
+      "profile.ClientProfileRequestPacket",
+      "profile.ClientProfileActivityPacket",
+      "cosmetic.ClientCosmeticRequestPacket",
+      "cosmetic.ClientCosmeticBulkRequestUnlockStatePacket",
+      "cosmetic.ClientCosmeticAnimationTriggerPacket",
+      "skin.ClientSkinCreatePacket",
+      "skin.ClientSkinUpdateLastUsedStatePacket",
+      "skin.ClientSkinUpdateFavoriteStatePacket",
+      "skin.ClientSelectedSkinsRequestPacket",
+      "cosmetic.outfit.ClientCosmeticOutfitCreatePacket",
+      "cosmetic.outfit.ClientCosmeticOutfitSelectPacket",
+      "cosmetic.outfit.ClientCosmeticOutfitEquippedCosmeticsUpdatePacket",
+      "cosmetic.emote.ClientCosmeticEmoteWheelUpdatePacket",
+      "cosmetic.emote.ClientCosmeticEmoteWheelSelectPacket",
+      "wardrobe.ClientWardrobeSettingsPacket",
+      "checkout.ClientCheckoutCosmeticsPacket",
+      "coins.ClientCoinsBalancePacket",
+      "notices.ClientNoticeRequestPacket",
+      "serverdiscovery.ClientServerDiscoveryRequestPacket",
+      "knownservers.ClientKnownServersRequestPacket",
+      "multiplayer.ClientMultiplayerIceRelayPacket",
+      "pingproxy.ClientPingProxyRequestPacket",
+      "social.ClientCommunityRulesAgreedPacket"
+    ];
+    for (const t of TYPES) this.codec.registerOutgoing(t);
+  }
+  // ----- Frame handling -----
+  handleFrame(data) {
+    const packet = this.codec.decode(data);
+    if (!packet) return;
+    this.emit("raw", packet);
+    this.dispatch(packet);
+  }
+  dispatch(packet) {
+    if (packet.id && this.pendingRequests.has(packet.id)) {
+      const req = this.pendingRequests.get(packet.id);
+      this.pendingRequests.delete(packet.id);
+      clearTimeout(req.timer);
+      req.resolve(packet);
+      return;
+    }
+    if (!this.bootstrapReceived && packet.type === "social.ServerCommunityRulesStatePacket") {
+      this.bootstrapReceived = true;
+      this.state = "ready";
+      this.emit("bootstrap", void 0);
+    }
+    switch (packet.type) {
+      case "chat.ServerChatChannelMessagePacket": {
+        const msgs = packet.payload.a || [];
+        for (const m of msgs) {
+          this.emit("chat", {
+            id: m.a,
+            channelId: m.b ?? 0,
+            senderUuid: m.c,
+            content: m.d,
+            replyToId: m.e ?? null,
+            editedAt: m.f ?? null,
+            deleted: m.g ?? false,
+            createdAt: m.h ?? Date.now()
+          });
+        }
+        break;
+      }
+      case "relationships.ServerRelationshipPopulatePacket": {
+        const rels = packet.payload.a || [];
+        for (const r of rels) {
+          this.emit("friendAdded", {
+            userA: r.a,
+            userB: r.b,
+            type: r.c,
+            status: r.d,
+            since: r.e
+          });
+        }
+        break;
+      }
+      case "relationships.ServerRelationshipDeletedPacket": {
+        const dels = packet.payload.a || [];
+        for (const d of dels) {
+          this.emit("friendRemoved", { userA: d.a, userB: d.b, type: d.c });
+        }
+        break;
+      }
+      case "profile.ServerProfileStatusPacket": {
+        this.emit("profileStatus", {
+          uuid: packet.payload.a,
+          status: packet.payload.b,
+          lastOnlineTimestamp: packet.payload.lastOnlineTimestamp ?? 0
+        });
+        break;
+      }
+      case "profile.ServerProfileActivityPacket": {
+        this.emit("profileActivity", {
+          uuid: packet.payload.a,
+          activity: packet.payload.b,
+          metadata: packet.payload.c
+        });
+        break;
+      }
+      case "cosmetic.ServerCosmeticAnimationTriggerPacket": {
+        this.emit("cosmeticAnimation", {
+          userUuid: packet.payload.a,
+          cosmeticId: packet.payload.b,
+          animationId: packet.payload.c
+        });
+        break;
+      }
+      case "notices.ServerNoticePopulatePacket": {
+        const items = packet.payload.items || packet.payload.a || [];
+        for (const n of items) {
+          this.emit("notice", { id: n.a, title: n.b, body: n.c, category: n.d });
+        }
+        break;
+      }
+      case "cosmetic.ServerCosmeticsUserUnlockedPacket": {
+        this.emit("cosmeticsUnlocked", {
+          userUuid: packet.payload.c,
+          unlockedIds: packet.payload.a ?? [],
+          gifted: packet.payload.b,
+          unlockMap: packet.payload.d ?? {}
+        });
+        break;
+      }
+      case "cosmetic.ServerCosmeticsUserEquippedPacket": {
+        this.emit("equippedUpdate", {
+          userUuid: packet.payload.a,
+          equipped: packet.payload.b
+        });
+        break;
+      }
+      case "cosmetic.ServerCosmeticPlayerSettingsPacket": {
+        this.emit("playerSettings", {
+          userUuid: packet.payload.a,
+          settings: packet.payload.b
+        });
+        break;
+      }
+      case "cosmetic.ServerCosmeticsSkinTexturePacket": {
+        this.emit("skinTexture", {
+          userUuid: packet.payload.a,
+          skinTexture: packet.payload.b
+        });
+        break;
+      }
+      case "upnp.ServerUPnPSessionPopulatePacket": {
+        const sessions = packet.payload.a || [];
+        for (const s of sessions) {
+          this.emit("upnpSession", {
+            hostUuid: s.a,
+            ip: s.b,
+            port: s.c,
+            privacy: s.d,
+            worldName: s.e,
+            protocolVersion: s.f,
+            invites: s.g ?? [],
+            createdAt: s.h,
+            rawStatus: s.i
+          });
+        }
+        break;
+      }
+      case "upnp.ServerUPnPSessionRemovePacket": {
+        const removed = packet.payload.a || [];
+        for (const hostUuid of removed) {
+          this.emit("upnpSessionRemoved", { hostUuid });
+        }
+        break;
+      }
+      case "upnp.ServerUPnPSessionInviteAddPacket": {
+        this.emit("upnpInvite", { hostUuid: packet.payload.a });
+        break;
+      }
+      case "serverdiscovery.ServerServerDiscoveryResponsePacket": {
+        this.emit("serverList", {
+          recommended: packet.payload.recommended || [],
+          featured: packet.payload.featured || []
+        });
+        break;
+      }
+    }
+  }
+  // ----- Request/response -----
+  sendRequest(type, payload, timeoutMs = this.defaultRequestTimeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error("WebSocket not connected"));
+        return;
+      }
+      const id = crypto.randomUUID();
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request ${type} timed out`));
+      }, timeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, type, timer });
+      for (const frame of this.codec.encode(type, payload, id)) {
+        this.ws.send(frame);
+      }
+    });
+  }
+  // ----- High-level API -----
+  // Chat
+  sendChatMessage(channelId, content, replyToId) {
+    return this.sendRequest("chat.ClientChatChannelMessageCreatePacket", {
+      a: channelId,
+      b: content,
+      c: replyToId ?? null
+    });
+  }
+  retrieveChatMessages(channelId, limit = 50, beforeMessageId) {
+    return this.sendRequest("chat.ClientChatChannelMessagesRetrievePacket", {
+      a: channelId,
+      b: limit,
+      c: beforeMessageId ?? null
+    });
+  }
+  createChannel(type, name, memberUuids = []) {
+    return this.sendRequest("chat.ClientChatChannelCreatePacket", {
+      a: type,
+      b: name,
+      c: memberUuids
+    });
+  }
+  deleteChatMessage(messageId) {
+    return this.sendRequest("chat.ChatChannelMessageDeletePacket", { a: messageId });
+  }
+  // Social
+  addFriend(targetUuid) {
+    return this.sendRequest("relationships.ClientRelationshipCreatePacket", {
+      a: targetUuid,
+      b: "FRIENDS"
+    });
+  }
+  removeFriend(targetUuid) {
+    return this.sendRequest("relationships.RelationshipDeletePacket", {
+      a: targetUuid,
+      b: "FRIENDS"
+    });
+  }
+  blockUser(targetUuid) {
+    return this.sendRequest("relationships.ClientRelationshipCreatePacket", {
+      a: targetUuid,
+      b: "BLOCKED"
+    });
+  }
+  lookupUuidByName(username) {
+    return this.sendRequest("relationships.ClientLookupUuidByNamePacket", { username });
+  }
+  // Profile
+  getProfile(uuid) {
+    return this.sendRequest("profile.ClientProfileRequestPacket", { a: uuid });
+  }
+  setActivity(activity, metadata = {}) {
+    return this.sendRequest("profile.ClientProfileActivityPacket", { a: activity, c: metadata });
+  }
+  // Cosmetics
+  listCosmetics() {
+    return this.sendRequest("cosmetic.ClientCosmeticRequestPacket", {});
+  }
+  triggerCosmeticAnimation(cosmeticId, animationId) {
+    return this.sendRequest("cosmetic.ClientCosmeticAnimationTriggerPacket", {
+      a: cosmeticId,
+      b: animationId
+    });
+  }
+  unlockCosmetics(cosmeticIds) {
+    return this.sendRequest("checkout.ClientCheckoutCosmeticsPacket", {
+      cosmetic_ids: cosmeticIds
+    });
+  }
+  // Skins
+  createSkin(name, model, hash) {
+    return this.sendRequest("skin.ClientSkinCreatePacket", { a: name, b: model, c: hash });
+  }
+  selectLastUsedSkin(skinId) {
+    return this.sendRequest("skin.ClientSkinUpdateLastUsedStatePacket", { a: skinId });
+  }
+  favoriteSkin(skinId, favorited) {
+    return this.sendRequest("skin.ClientSkinUpdateFavoriteStatePacket", {
+      a: skinId,
+      b: favorited
+    });
+  }
+  // Outfits
+  createOutfit(name, equippedCosmetics, settings = {}) {
+    return this.sendRequest("cosmetic.outfit.ClientCosmeticOutfitCreatePacket", {
+      name,
+      skin_id: null,
+      equipped_cosmetics: equippedCosmetics,
+      cosmetic_settings: settings
+    });
+  }
+  selectOutfit(outfitId) {
+    return this.sendRequest("cosmetic.outfit.ClientCosmeticOutfitSelectPacket", { a: outfitId });
+  }
+  setEquippedCosmetic(outfitId, slot, cosmeticId) {
+    return this.sendRequest("cosmetic.outfit.ClientCosmeticOutfitEquippedCosmeticsUpdatePacket", {
+      a: outfitId,
+      b: slot,
+      c: cosmeticId
+    });
+  }
+  // Emote wheel
+  updateEmoteWheel(wheelId, slots) {
+    return this.sendRequest("cosmetic.emote.ClientCosmeticEmoteWheelUpdatePacket", {
+      a: wheelId,
+      b: slots
+    });
+  }
+  selectEmoteWheel(wheelId) {
+    return this.sendRequest("cosmetic.emote.ClientCosmeticEmoteWheelSelectPacket", { a: wheelId });
+  }
+  // Wardrobe settings
+  getWardrobeSettings() {
+    return this.sendRequest("wardrobe.ClientWardrobeSettingsPacket", {});
+  }
+  // Discovery
+  listNotices() {
+    return this.sendRequest("notices.ClientNoticeRequestPacket", {});
+  }
+  listServerDiscovery() {
+    return this.sendRequest("serverdiscovery.ClientServerDiscoveryRequestPacket", {});
+  }
+  listKnownServers() {
+    return this.sendRequest("knownservers.ClientKnownServersRequestPacket", {});
+  }
+  // Multiplayer
+  relayIcePacket(targetUuid, payload) {
+    return this.sendRequest("multiplayer.ClientMultiplayerIceRelayPacket", {
+      a: targetUuid,
+      b: Array.from(payload)
+    });
+  }
+  pingServer(host, port, protocolVersion) {
+    return this.sendRequest("pingproxy.ClientPingProxyRequestPacket", {
+      a: host,
+      b: port,
+      c: protocolVersion ?? 0
+    });
+  }
+  // UPnP server hosting
+  createSession(ip, port, privacy, worldName, protocolVersion) {
+    return this.sendRequest("upnp.ClientUPnPSessionCreatePacket", {
+      a: ip,
+      b: port,
+      c: privacy,
+      d: protocolVersion,
+      e: worldName
+    });
+  }
+  closeSession() {
+    return this.sendRequest("upnp.ClientUPnPSessionClosePacket", {});
+  }
+  updateSession(patch) {
+    return this.sendRequest("upnp.ClientUPnPSessionUpdatePacket", {
+      a: patch.ip,
+      b: patch.port,
+      c: patch.privacy
+    });
+  }
+  inviteToSession(inviteeUuids) {
+    return this.sendRequest("upnp.ClientUPnPSessionInvitesAddPacket", { a: inviteeUuids });
+  }
+  revokeSessionInvites(inviteeUuids) {
+    return this.sendRequest("upnp.ClientUPnPSessionInvitesRemovePacket", { a: inviteeUuids });
+  }
+  pushServerStatus(rawStatus) {
+    return this.sendRequest("upnp.ClientUPnPSessionPingProxyUpdatePacket", { a: rawStatus });
+  }
+  // Social invite
+  inviteFriendToServer(targetUuid, address) {
+    return this.sendRequest("social.ClientSocialInviteRequestPacket", {
+      a: targetUuid,
+      b: address
+    });
+  }
+  // ----- Event emitter -----
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, data) {
+    for (const l of this.listeners.get(event) ?? []) {
+      try {
+        l(data);
+      } catch (e) {
+      }
+    }
+  }
+  isReady() {
+    return this.state === "ready";
+  }
+  isConnected() {
+    return this.state === "connected" || this.state === "ready";
+  }
+};
+
+exports.AnvilWsClient = AnvilWsClient;
+exports.ConnectionCodec = ConnectionCodec;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map