@laplace.live/ws 6.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 simon3000
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,294 @@
+# bilibili-live-ws [![npm](https://img.shields.io/npm/v/bilibili-live-ws.svg)](https://www.npmjs.com/package/bilibili-live-ws) ![Node CI](https://github.com/simon300000/bilibili-live-ws/workflows/Node%20CI/badge.svg)
+
+Bilibili 直播 WebSocket/TCP API
+
+LiveWS/KeepLiveWS 支持浏览器 *(实验性)*
+
+应该支持 bilibili直播开放平台 <https://open-live.bilibili.com>
+
+注：如果在浏览器环境遇到问题，可以尝试手动指定引入 `bilibili-live-ws/browser`
+
+## API
+
+```javascript
+const { LiveWS, LiveTCP, KeepLiveWS, KeepLiveTCP } = require('bilibili-live-ws')
+const live = new LiveWS(roomid)
+// 或
+const live = new LiveTCP(roomid)
+```
+
+举个栗子:
+
+```javascript
+const live = new LiveWS(14275133)
+
+live.on('open', () => console.log('Connection is established'))
+// Connection is established
+live.on('live', () => {
+  live.on('heartbeat', console.log)
+  // 74185
+})
+```
+
+或者用TCP (新功能):
+
+```javascript
+const live = new LiveTCP(26283)
+
+live.on('open', () => console.log('Connection is established'))
+// Connection is established
+live.on('live', () => {
+  live.on('heartbeat', console.log)
+  // 13928
+})
+```
+
+> 晚上做梦梦到一个白胡子的老爷爷和我说TCP更节约内存哦！
+
+## Class: LiveWS / LiveTCP / KeepLiveWS / KeepLiveTCP
+
+(Keep)LiveWS 和 (Keep)LiveTCP 的大部分API基本上一样, 区别在本文末尾有注明
+
+### new LiveWS(roomid [, { address, protover, key, authBody, uid, buvid }])
+
+### new LiveTCP(roomid [, { host, port, protover, key, authBody, uid, buvid }])
+
+- `roomid` 房间号
+
+  比如 https://live.bilibili.com/14327465 中的 `14327465`
+  
+- `address` 可选, WebSocket连接的地址
+
+  默认 `'wss://broadcastlv.chat.bilibili.com/sub'`
+
+- `host` 可选, TCP连接的地址
+
+  默认 `'broadcastlv.chat.bilibili.com'`
+
+- `port` 可选, TCP连接的端口
+
+  默认 `2243`
+  
+- `protover` 可选 (1, 2, 3)
+
+  默认 `2`
+  
+  * 1 (见 [#17](https://github.com/simon300000/bilibili-live-ws/issues/17))
+  * 2 (zlib.inflate)
+  * 3 (brotliDecompress)
+  
+- `uid` 可选, WS握手的 uid [#397](https://github.com/simon300000/bilibili-live-ws/issues/397)
+
+- `key` 可选, WS握手的 Token [#397](https://github.com/simon300000/bilibili-live-ws/issues/397)
+
+- `buvid` 可选, WS握手的 Token [#397](https://github.com/simon300000/bilibili-live-ws/issues/397)
+
+- `authBody` 可选, 可以和 <https://open-live.bilibili.com/document/> 配合使用, 会覆盖掉 `protover` `roomid` `key` `uid` `buvid`. 如果是 `object` 会按照握手包编码，如果是 `string`/`Buffer` 会直接发送
+
+#### live.on('open')
+
+WebSocket连接上了
+
+#### live.on('live')
+
+成功登入房间
+
+#### live.on('heartbeat', (online) => ...)
+
+收到服务器心跳包，会在30秒之后自动发送心跳包。
+
+- `online` 当前人气值
+
+#### live.on('msg', (data) => ...)
+
+- `data` 收到信息/弹幕/广播等
+
+  data的例子: (我simon3000送了一个辣条)
+
+  ```javascript
+  {
+    cmd: 'SEND_GIFT',
+    data: {
+      giftName: '辣条',
+      num: 1,
+      uname: 'simon3000',
+      face: 'http://i1.hdslb.com/bfs/face/c26b9f670b10599ad105e2a7fea4b5f21c0f0bcf.jpg',
+      guard_level: 0,
+      rcost: 2318827,
+      uid: 3499295,
+      top_list: [],
+      timestamp: 1555690631,
+      giftId: 1,
+      giftType: 0,
+      action: '喂食',
+      super: 0,
+      super_gift_num: 0,
+      price: 100,
+      rnd: '1555690616',
+      newMedal: 0,
+      newTitle: 0,
+      medal: [],
+      title: '',
+      beatId: '0',
+      biz_source: 'live',
+      metadata: '',
+      remain: 6,
+      gold: 0,
+      silver: 0,
+      eventScore: 0,
+      eventNum: 0,
+      smalltv_msg: [],
+      specialGift: null,
+      notice_msg: [],
+      capsule: null,
+      addFollow: 0,
+      effect_block: 1,
+      coin_type: 'silver',
+      total_coin: 100,
+      effect: 0,
+      tag_image: '',
+      user_count: 0
+    }
+  }
+  ```
+
+#### live.on(cmd, (data) => ...)
+
+用法如上，只不过只会收到特定cmd的Event。
+
+比如 `live.on('DANMU_MSG')` 只会收到弹幕Event，一个弹幕Event的Data例子如下: (我simon3000发了个`233`)
+
+```javascript
+{
+  cmd: 'DANMU_MSG',
+  info: [
+    [0, 1, 25, 16777215, 1555692037, 1555690616, 0, 'c5c630b1', 0, 0, 0],
+    '233',
+    [3499295, 'simon3000', 0, 0, 0, 10000, 1, ''],
+    [5, '財布', '神楽めあOfficial', 12235923, 5805790, ''],
+    [11, 0, 6406234, '>50000'],
+    ['title-58-1', 'title-58-1'],
+    0,
+    0,
+    null,
+    { ts: 1555692037, ct: '2277D56A' }
+  ]
+}
+```
+
+
+
+#### live.on('close')
+
+连接关闭事件
+
+#### live.on('error', (e) => ...)
+
+连接 error 事件，连接同时也会关闭
+
+#### live.heartbeat()
+
+无视30秒时间，直接发送一个心跳包。
+
+如果连接正常，会收到来自服务器的心跳包，也就是 `live.on('heartbeat')`，可以用于更新人气值。
+
+#### live.close()
+
+关闭WebSocket/TCP Socket连接。
+
+#### live.getOnline()
+
+立即调用 `live.heartbeat()` 刷新人气数值，并且返回 Promise，resolve 人气刷新后数值
+
+#### live.on('message')
+
+WebSocket/TCP收到的Raw Buffer（不推荐直接使用）
+
+#### live.send(buffer)
+
+使用 WebSocket 或者 TCP 发送信息
+
+### getConf(roomid)
+
+选一个cdn，Resolve host, address 和 key, 可以直接放进(Keep)LiveWS/TCP设置
+
+```typescript
+const { getConf } = require('bilibili-live-ws')
+
+getConf(roomid)
+// Return
+Promise<{
+    key: string;
+    host: string;
+    address: string;
+}>
+```
+
+### getRoomid(short)
+
+通过短房间号获取长房间号
+
+```typescript
+const { getRoomid } = require('bilibili-live-ws')
+
+getRoomid(255)
+// Return Promise<number>: 48743
+```
+
+<hr>
+
+### Keep和无Keep的区别
+
+KeepLiveWS 和 KeepLiveTCP 有断线重新连接的功能
+
+#### new KeepLiveWS(roomid [, { address, protover, key }])
+
+#### new KeepLiveTCP(roomid [, { host, port, protover, key }])
+
+所有上方的API都是一样的, 只不过会有以下微小的区别
+
+* 收到error或者close事件的时候并不代表连接关闭, 必须要手动调用`live.close()`来关闭连接
+* 内部的连接对象(`LiveWS`/`LiveTCP`)在`live.connection`中
+* 内部的连接关闭了之后, 如果不是因为`live.close()`关闭, 会在100毫秒之后自动打开一个新的连接。
+  * 这个100毫秒可以通过改变`live.interval`来设置
+* 内部的boolean, `live.closed`, 用于判断是否是因为`live.close()`关闭。
+
+<hr>
+
+### LiveWS 和 LiveTCP 的区别
+
+#### LiveWS.ws
+
+LiveWS 内部 WebSocket 对象，需要时可以直接操作
+
+Doc: <https://github.com/websockets/ws/blob/master/doc/ws.md#class-websocket>
+
+#### LiveTCP.socket
+
+LiveTCP 内部 TCP Socket 对象，需要时可以直接操作
+
+Doc: <https://nodejs.org/api/net.html#net_class_net_socket>
+
+#### LiveTCP.buffer
+
+LiveTCP内部TCP流的Buffer缓冲区，有不完整的包
+
+#### LiveTCP.splitBuffer()
+
+处理LiveTCP内部TCP流的Buffer缓冲区，把其中完整的包交给decoder处理
+
+### BenchMark 简单对比
+
+在连接了640个直播间后过了一分钟左右(@2.0.0)
+
+|          | LiveWS (wss) | LiveWS (ws) | LiveTCP |
+| -------- | ------------ | ----------- | ------- |
+| 内存占用 | 63 MB        | 26 MB       | 18 MB   |
+
+<hr>
+
+参考资料: <https://github.com/lovelyyoshino/Bilibili-Live-API/blob/master/API.WebSocket.md>
+
+# 贡献
+
+欢迎Issue和Pull Request！

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@laplace.live/ws",
+  "version": "6.3.1",
+  "description": "Bilibili Live WebSocket/TCP API",
+  "type": "module",
+  "main": "./src/index.ts",
+  "browser": "./src/browser.ts",
+  "exports": {
+    ".": {
+      "browser": "./src/browser.ts",
+      "default": "./src/index.ts"
+    },
+    "./browser": "./src/browser.ts"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "bun test --timeout 5000"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laplace-live/ws.git"
+  },
+  "keywords": [
+    "bilibili",
+    "api",
+    "websocket",
+    "live",
+    "ws",
+    "tcp"
+  ],
+  "author": "simon3000 <simon3000@163.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/laplace-live/ws/issues"
+  },
+  "homepage": "https://github.com/laplace-live/ws#readme",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "isomorphic-ws": "^5.0.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.6",
+    "@types/bun": "^1.3.10",
+    "@types/pako": "^2.0.4",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "buffer": "^6.0.3",
+    "events": "^3.3.0",
+    "pako": "^2.1.0"
+  }
+}

package/src/browser.ts

@@ -0,0 +1,20 @@
+import { KeepLive } from './common'
+import { inflates } from './inflate/browser'
+import { LiveWSBase, type WSOptions } from './ws'
+
+export type { LiveOptions } from './common'
+export type { WSOptions } from './ws'
+
+export { relayEvent } from './common'
+
+export class LiveWS extends LiveWSBase {
+  constructor(roomid: number, opts?: WSOptions) {
+    super(inflates, roomid, opts)
+  }
+}
+
+export class KeepLiveWS extends KeepLive<typeof LiveWSBase> {
+  constructor(roomid: number, opts?: WSOptions) {
+    super(LiveWSBase, inflates, roomid, opts)
+  }
+}

package/src/buffer.ts

@@ -0,0 +1,82 @@
+export type { Buffer } from 'buffer'
+export type Inflates = { inflateAsync: (b: Buffer) => Buffer | Promise<Buffer>, brotliDecompressAsync: (b: Buffer) => Buffer | Promise<Buffer>, Buffer: typeof Buffer }
+
+// https://github.com/lovelyyoshino/Bilibili-Live-API/blob/master/API.WebSocket.md
+
+const cutBuffer = (buffer: Buffer) => {
+  const bufferPacks: Buffer[] = []
+  let size: number
+  for (let i = 0; i < buffer.length; i += size) {
+    size = buffer.readInt32BE(i)
+    bufferPacks.push(buffer.slice(i, i + size))
+  }
+  return bufferPacks
+}
+
+export const makeDecoder = ({ inflateAsync, brotliDecompressAsync }: Inflates) => {
+  const decoder = async (buffer: Buffer) => {
+    const packs = await Promise.all(cutBuffer(buffer)
+      .map(async buf => {
+        const body = buf.slice(16)
+        const protocol = buf.readInt16BE(6)
+        const operation = buf.readInt32BE(8)
+
+        let type = 'unknow'
+        if (operation === 3) {
+          type = 'heartbeat'
+        } else if (operation === 5) {
+          type = 'message'
+        } else if (operation === 8) {
+          type = 'welcome'
+        }
+
+        let data: any
+        if (protocol === 0) {
+          data = JSON.parse(String(body))
+        }
+        if (protocol === 1 && body.length === 4) {
+          data = body.readUIntBE(0, 4)
+        }
+        if (protocol === 2) {
+          data = await decoder(await inflateAsync(body))
+        }
+        if (protocol === 3) {
+          data = await decoder(await brotliDecompressAsync(body))
+        }
+
+        return { buf, type, protocol, data }
+      }))
+
+    return packs.flatMap(pack => {
+      if (pack.protocol === 2 || pack.protocol === 3) {
+        return pack.data as typeof packs
+      }
+      return pack
+    })
+  }
+
+  return decoder
+}
+
+type EncodeType = 'heartbeat' | 'join'
+
+export const encoder = (type: EncodeType, { Buffer }: Inflates, body: any = '') => {
+  const blank = Buffer.alloc(16)
+  if (typeof body !== 'string') {
+    body = JSON.stringify(body)
+  }
+  const head = Buffer.from(blank)
+  const buffer = Buffer.from(body)
+
+  head.writeInt32BE(buffer.length + head.length, 0)
+  head.writeInt16BE(16, 4)
+  head.writeInt16BE(1, 6)
+  if (type === 'heartbeat') {
+    head.writeInt32BE(2, 8)
+  }
+  if (type === 'join') {
+    head.writeInt32BE(7, 8)
+  }
+  head.writeInt32BE(1, 12)
+  return Buffer.concat([head, buffer])
+}

package/src/common.ts

@@ -0,0 +1,216 @@
+import { EventEmitter } from 'events'
+
+import { encoder, type Inflates, makeDecoder } from './buffer'
+
+export type LiveOptions = { protover?: 1 | 2 | 3; key?: string; authBody?: any; uid?: number; buvid?: string }
+
+export const relayEvent = Symbol('relay')
+
+class NiceEventEmitter extends EventEmitter {
+  emit(eventName: string | symbol, ...params: any[]) {
+    super.emit(eventName, ...params)
+    super.emit(relayEvent, eventName, ...params)
+    return true
+  }
+}
+
+export class Live extends NiceEventEmitter {
+  roomid: number
+  online: number
+  live: boolean
+  closed: boolean
+  timeout: ReturnType<typeof setTimeout>
+
+  inflates: Inflates
+
+  send: (data: Buffer) => void
+  close: () => void
+
+  constructor(
+    inflates: Inflates,
+    roomid: number,
+    {
+      send,
+      close,
+      protover = 3,
+      key,
+      authBody,
+      uid = 0,
+      buvid,
+    }: { send: (data: Buffer) => void; close: () => void } & LiveOptions
+  ) {
+    if (typeof roomid !== 'number' || Number.isNaN(roomid)) {
+      throw new Error(`roomid ${roomid} must be Number not NaN`)
+    }
+
+    super()
+    this.inflates = inflates
+    this.roomid = roomid
+    this.online = 0
+    this.live = false
+    this.closed = false
+    this.timeout = setTimeout(() => {}, 0)
+
+    this.send = send
+    this.close = () => {
+      this.closed = true
+      close()
+    }
+
+    this.on('message', async buffer => {
+      const packs = await makeDecoder(inflates)(buffer)
+      packs.forEach(({ type, data }) => {
+        if (type === 'welcome') {
+          this.live = true
+          this.emit('live')
+          this.send(encoder('heartbeat', inflates))
+        }
+        if (type === 'heartbeat') {
+          this.online = data
+          clearTimeout(this.timeout)
+          this.timeout = setTimeout(() => this.heartbeat(), 1000 * 30)
+          this.emit('heartbeat', this.online)
+        }
+        if (type === 'message') {
+          this.emit('msg', data)
+          const cmd = data.cmd || (data.msg && data.msg.cmd)
+          if (cmd) {
+            if (cmd.includes('DANMU_MSG')) {
+              this.emit('DANMU_MSG', data)
+            } else {
+              this.emit(cmd, data)
+            }
+          }
+        }
+      })
+    })
+
+    this.on('open', () => {
+      if (authBody) {
+        if (typeof authBody === 'object') {
+          authBody = encoder('join', inflates, authBody)
+        }
+        this.send(authBody)
+      } else {
+        const hi: {
+          uid: number
+          roomid: number
+          protover: number
+          platform: string
+          type: number
+          key?: string
+          buvid?: string
+        } = { uid: uid, roomid, protover, platform: 'web', type: 2 }
+        if (key) {
+          hi.key = key
+        }
+        if (buvid) {
+          hi.buvid = buvid
+        }
+        const buf = encoder('join', inflates, hi)
+        this.send(buf)
+      }
+    })
+
+    this.on('close', () => {
+      clearTimeout(this.timeout)
+    })
+
+    this.on('_error', error => {
+      this.close()
+      this.emit('error', error)
+    })
+  }
+
+  heartbeat() {
+    this.send(encoder('heartbeat', this.inflates))
+  }
+
+  getOnline() {
+    this.heartbeat()
+    return new Promise<number>(resolve => this.once('heartbeat', resolve))
+  }
+}
+
+export class KeepLive<Base extends typeof Live> extends EventEmitter {
+  params: ConstructorParameters<Base>
+  closed: boolean
+  interval: number
+  timeout: number
+  connection: InstanceType<Base>
+  Base: Base
+
+  constructor(Base: Base, ...params: ConstructorParameters<Base>) {
+    super()
+    this.params = params
+    this.closed = false
+    this.interval = 100
+    this.timeout = 45 * 1000
+    this.connection = new (Base as any)(...this.params)
+    this.Base = Base
+    this.connect(false)
+  }
+
+  connect(reconnect = true) {
+    if (reconnect) {
+      this.connection.close()
+      this.connection = new (this.Base as any)(...this.params)
+    }
+    const connection = this.connection
+
+    let timeout = setTimeout(() => {
+      connection.close()
+      connection.emit('timeout')
+    }, this.timeout)
+
+    connection.on(relayEvent, (eventName: string, ...params: any[]) => {
+      if (eventName !== 'error') {
+        this.emit(eventName, ...params)
+      }
+    })
+
+    connection.on('error', e => this.emit('e', e))
+    connection.on('close', () => {
+      if (!this.closed) {
+        setTimeout(() => this.connect(), this.interval)
+      }
+    })
+
+    connection.on('heartbeat', () => {
+      clearTimeout(timeout)
+      timeout = setTimeout(() => {
+        connection.close()
+        connection.emit('timeout')
+      }, this.timeout)
+    })
+
+    connection.on('close', () => {
+      clearTimeout(timeout)
+    })
+  }
+
+  get online() {
+    return this.connection.online
+  }
+
+  get roomid() {
+    return this.connection.roomid
+  }
+
+  close() {
+    this.closed = true
+    this.connection.close()
+  }
+
+  heartbeat() {
+    return this.connection.heartbeat()
+  }
+
+  getOnline() {
+    return this.connection.getOnline()
+  }
+
+  send(data: Buffer) {
+    return this.connection.send(data)
+  }
+}