@zhin.js/adapter-onebot11 1.0.97 → 1.1.0

package/src/side-event-dispatch.ts

@@ -0,0 +1,48 @@
+import { receiveOneBotLikeSideEvent } from '@zhin.js/core';
+import type { EndpointEventEmitter } from 'zhin.js/adapter';
+import { formatCompact, type getAdapterLogger } from '@zhin.js/logger';
+import type { OneBot11Event } from './protocol.js';
+
+export interface OneBot11SideEventCaller {
+  callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
+}
+
+export function receiveOneBot11SideEvent(
+  emit: EndpointEventEmitter,
+  endpointKey: string,
+  caller: OneBot11SideEventCaller,
+  raw: OneBot11Event,
+  logger: ReturnType<typeof getAdapterLogger>,
+): void {
+  if (!emit) return;
+  const record = raw as Record<string, unknown>;
+  const postType = String(record.post_type ?? '');
+  const requestType = String(record.request_type ?? '');
+  const isRequest = postType === 'request' || postType.startsWith('request.');
+  const isFriend = requestType === 'friend' || postType.includes('friend');
+  void receiveOneBotLikeSideEvent(emit, {
+    adapter: 'onebot11',
+    endpointKey,
+    platform: 'onebot',
+    raw: record,
+    ...(isRequest ? {
+      approve: async (flag, remark) => {
+        await (isFriend
+          ? caller.callApi('set_friend_add_request', { flag, approve: true, remark })
+          : caller.callApi('set_group_add_request', { flag, approve: true, reason: remark }));
+      },
+      reject: async (flag, reason) => {
+        await (isFriend
+          ? caller.callApi('set_friend_add_request', { flag, approve: false })
+          : caller.callApi('set_group_add_request', { flag, approve: false, reason }));
+      },
+    } : {}),
+  }).catch((err) => {
+    logger.warn(formatCompact({
+      op: 'onebot11_side_event_failed',
+      endpoint: endpointKey,
+      post_type: postType || undefined,
+      error: err instanceof Error ? err.message : String(err),
+    }));
+  });
+}

package/src/ws-endpoint.ts

@@ -0,0 +1,272 @@
+/**
+ * OneBot11 WS client endpoint — outbound connect to OneBot implementation.
+ */
+import WebSocket from 'ws';
+import {
+  ClientEndpoint,
+  createRecallEndpointControl,
+  createEndpointLifecycle,
+  type EndpointConnectHandle,
+  type EndpointControl,
+  type EndpointLifecycle,
+  type EndpointManagement,
+  type EndpointSendRequest,
+} from 'zhin.js/adapter';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import type { CapabilityId } from 'zhin.js';
+import { createOneBot11EndpointManagement } from './endpoint-management.js';
+import {
+  buildSendAction,
+  buildWsConnectOptions,
+  formatInboundContent,
+  formatInboundMetadata,
+  formatOutboundSegments,
+  isMessageEvent,
+  onebot11InboundConversation,
+  senderDisplayName,
+  senderUserId,
+  type OneBot11Event,
+  type OneBot11WsConfig,
+} from './protocol.js';
+import { receiveOneBot11SideEvent } from './side-event-dispatch.js';
+import { createOneBot11ContentPort } from './content-port.js';
+import {
+  callOneBot11WsAction,
+  handleOneBot11WsMessage,
+  rejectAllPending,
+} from './ws-transport.js';
+import {
+  type OneBot11PendingAction,
+  type OneBot11WsCreateOptions,
+  type OneBot11WsSocket,
+} from './ws-types.js';
+import { callOnebot11Client, createOnebot11EndpointClient, forwardOnebot11ClientEvents, type Onebot11Client } from './client.js';
+
+export interface OneBot11WsEndpointOptions {
+  readonly id: CapabilityId;
+  readonly config: OneBot11WsConfig;
+  readonly createWebSocket?: (
+    url: string,
+    options: OneBot11WsCreateOptions,
+  ) => OneBot11WsSocket;
+}
+
+export class OneBot11WsEndpoint extends ClientEndpoint<Onebot11Client> {
+  readonly client: Onebot11Client;
+  readonly #logger!: ReturnType<typeof getAdapterLogger>;
+
+  readonly #options: OneBot11WsEndpointOptions;
+  readonly management: EndpointManagement;
+  readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
+  readonly content;
+  readonly #lifecycle: EndpointLifecycle;
+  #ws?: OneBot11WsSocket;
+  #requestId = { value: 0 };
+  #pending = new Map<string, OneBot11PendingAction>();
+
+  constructor(options: OneBot11WsEndpointOptions) {
+    super();
+    this.#logger = getAdapterLogger('onebot11', options.config.id);
+    this.#options = options;
+    this.client = createOnebot11EndpointClient(options.config, (action, params) => this.#callApi(action, params));
+    const callApi = (action: string, params?: Record<string, unknown>) => callOnebot11Client(this.client, action, params);
+    this.management = createOneBot11EndpointManagement({ callApi });
+    this.content = createOneBot11ContentPort(callApi);
+    this.bindClientEvents(
+      (receive) => forwardOnebot11ClientEvents(this.client, receive),
+      (name, payload) => {
+        if (name === 'event') this.#admitRaw(payload as OneBot11Event);
+      },
+      (_name, error) => this.#warnPlatformEvent(error),
+    );
+    const { config } = options;
+    this.#lifecycle = createEndpointLifecycle({
+      name: config.id,
+      reconnect: {
+        initialIntervalMs: config.reconnect_interval,
+        // 固定间隔（multiplier 1、无抖动），对齐旧 reconnect_interval 语义
+        multiplier: 1,
+        maxIntervalMs: config.reconnect_interval,
+        jitterMs: 0,
+      },
+      heartbeat: { intervalMs: config.heartbeat_interval },
+    });
+  }
+
+  async start(): Promise<void> {
+    if (this.#lifecycle.started) return;
+    try {
+      await this.#lifecycle.start((handle) => this.#connect(handle));
+    } catch (err) {
+      // start 失败必须清理现场（状态复位由基座保证）
+      if (this.#ws) {
+        try {
+          this.#ws.close();
+        } catch {
+          /* ignore */
+        }
+        this.#ws = undefined;
+      }
+      throw err;
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.close();
+    // 基座负责：清重连/心跳定时器、强关 ws、唤醒 stop-during-connect 竞态
+    await this.#lifecycle.stop();
+    rejectAllPending(this.#pending);
+    this.#ws = undefined;
+  }
+
+  async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
+    const message = formatOutboundSegments(payload);
+    const { action, params } = buildSendAction(conversation, message);
+    const data = await callOnebot11Client<{ message_id?: number | string }>(this.client, action, params);
+    const messageId = data?.message_id != null ? String(data.message_id) : '';
+    this.#logger.debug(formatCompact({
+      op: 'onebot11_send',
+      endpoint: this.#options.config.id,
+      target: `${conversation.kind}:${conversation.id}`,
+      messageId,
+    }));
+    return messageId;
+  }
+
+  async recallMessage(messageId: string): Promise<void> {
+    if (!messageId) return;
+    await callOnebot11Client(this.client, 'delete_msg', { message_id: Number(messageId) });
+  }
+
+  #callApi(
+    action: string,
+    params: Record<string, unknown> = {},
+  ): ReturnType<typeof callOneBot11WsAction> {
+    return callOneBot11WsAction(this.#ws, this.#pending, this.#requestId, action, params);
+  }
+
+  #admitRaw(ev: OneBot11Event): void {
+    if (!isMessageEvent(ev)) {
+      receiveOneBot11SideEvent(
+        (name, payload) => this.emit(name, payload),
+        this.#options.config.id,
+        { callApi: (action, params) => callOnebot11Client(this.client, action, params) },
+        ev,
+        this.#logger,
+      );
+      return;
+    }
+    const conversation = onebot11InboundConversation(String(this.#options.id), ev);
+    const content = formatInboundContent(ev);
+    const inbound = formatInboundMetadata(ev, this.#options.config.id);
+    void this.emit('message.receive', {
+      conversation,
+      message: { conversation, id: String(ev.message_id) },
+      content,
+      sender: {
+        id: senderUserId(ev),
+        name: senderDisplayName(ev) || undefined,
+        ...(ev.sender?.role ? { roles: [ev.sender.role] } : {}),
+      },
+      endpointId: inbound.endpointId,
+      ...(inbound.mentioned ? { mentioned: true } : {}),
+      ...(inbound.replyTo ? { replyTo: inbound.replyTo } : {}),
+      metadata: inbound.metadata,
+    }).catch((err) => {
+      this.#logger.warn(formatCompact({
+        op: 'onebot11_gateway_receive_failed',
+        target: `${conversation.kind}:${conversation.id}`,
+        error: err instanceof Error ? err.message : String(err),
+      }));
+    });
+  }
+
+  #warnPlatformEvent(error: unknown): void {
+    this.#logger.warn(formatCompact({
+      op: 'onebot11_platform_event_failed',
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+
+  async #connect(handle: EndpointConnectHandle): Promise<void> {
+    const { url, headers, safeUrl } = buildWsConnectOptions(this.#options.config);
+    const create = this.#options.createWebSocket
+      ?? ((connectUrl: string, options: OneBot11WsCreateOptions) =>
+        new WebSocket(connectUrl, { headers: options.headers }) as unknown as OneBot11WsSocket);
+
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+      const ws = create(url, { headers });
+      this.#ws = ws;
+      handle.onForceClose(() => {
+        try {
+          ws.close();
+        } catch {
+          /* ignore */
+        }
+      });
+
+      ws.on('open', () => {
+        if (settled) return;
+        settled = true;
+        if (!this.#options.config.access_token) {
+          this.#logger.warn(formatCompact({
+            endpoint: this.#options.config.id,
+            ok: false,
+            error: 'missing access_token',
+          }));
+        }
+        this.#logger.debug(formatCompact({
+          endpoint: this.#options.config.id,
+          mode: 'ws',
+          url: safeUrl,
+        }));
+        this.#lifecycle.startHeartbeat(() => this.#ws?.ping?.());
+        resolve();
+      });
+
+      ws.on('message', (data) => {
+        handleOneBot11WsMessage(data, {
+          endpointId: this.#options.config.id,
+          pending: this.#pending,
+          ingest: (ev) => this.client.ingest(ev as Parameters<Onebot11Client['ingest']>[0]),
+        });
+      });
+
+      ws.on('close', (code, reason) => {
+        const reasonStr = typeof reason === 'string'
+          ? reason
+          : Buffer.isBuffer(reason)
+            ? reason.toString()
+            : String(reason ?? '');
+        const codeNum = typeof code === 'number' ? code : Number(code ?? 0);
+        const codeHint = codeNum === 1005
+          ? ' [无状态，多为服务端/代理未发 close 帧即断开]'
+          : codeNum === 1006
+            ? ' [异常关闭]'
+            : '';
+        if (!settled) {
+          settled = true;
+          reject(new Error(`OneBot11 WS 关闭: ${codeNum} ${reasonStr}`));
+        }
+        // 断开日志与重连武装均由基座负责；仅曾 open 的连接才会武装重连，
+        // 初始连接失败由 start() 的拒绝路径复位，不产生僵尸重连。
+        handle.notifyClosed(`OneBot11 WS 关闭: ${codeNum} ${reasonStr || 'closed'}${codeHint}`);
+      });
+
+      ws.on('error', (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.#logger.warn(formatCompact({
+          op: 'ws_error',
+          endpoint: this.#options.config.id,
+          ok: false,
+          error: error.message,
+        }));
+        if (!settled) {
+          settled = true;
+          reject(error);
+        }
+      });
+    });
+  }
+}

package/src/ws-transport.ts

@@ -0,0 +1,100 @@
+import { clearInterval, clearTimeout, setInterval, setTimeout } from 'node:timers';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import {
+  type OneBot11ActionRequest,
+  type OneBot11ActionResponse,
+  type OneBot11Event,
+} from './protocol.js';
+import {
+  WS_OPEN,
+  type OneBot11PendingAction,
+  type OneBot11WsSocket,
+} from './ws-types.js';
+
+const logger = getLogger('onebot11');
+
+export function decodeWsPayload(data: unknown): string {
+  if (typeof data === 'string') return data;
+  if (Buffer.isBuffer(data)) return data.toString();
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+  return String(data ?? '');
+}
+
+export function handleOneBot11WsMessage(
+  data: unknown,
+  options: {
+    readonly endpointId: string;
+    readonly pending: Map<string, OneBot11PendingAction>;
+    readonly ingest: (ev: OneBot11Event) => void;
+  },
+): void {
+  try {
+    const raw = decodeWsPayload(data);
+    const msg = JSON.parse(raw) as OneBot11Event | OneBot11ActionResponse;
+    if ('echo' in msg && typeof (msg as OneBot11ActionResponse).echo === 'string') {
+      const resp = msg as OneBot11ActionResponse;
+      const pending = options.pending.get(resp.echo!);
+      if (pending) {
+        options.pending.delete(resp.echo!);
+        clearTimeout(pending.timeout);
+        pending.resolve(resp);
+      }
+      return;
+    }
+    options.ingest(msg as OneBot11Event);
+  } catch (error) {
+    logger.warn(formatCompact({
+      op: 'onebot11_parse_failed',
+      endpoint: options.endpointId,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+}
+
+export function callOneBot11WsAction(
+  ws: OneBot11WsSocket | undefined,
+  pending: Map<string, OneBot11PendingAction>,
+  requestId: { value: number },
+  action: string,
+  params: Record<string, unknown>,
+): Promise<OneBot11ActionResponse> {
+  if (!ws || ws.readyState !== WS_OPEN) {
+    return Promise.reject(new Error('WebSocket 未连接'));
+  }
+  const echo = `ob11_${++requestId.value}`;
+  const req: OneBot11ActionRequest = { action, params, echo };
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pending.delete(echo);
+      reject(new Error(`OneBot11 动作超时: ${action}`));
+    }, 30_000);
+    pending.set(echo, { resolve, reject, timeout });
+    ws.send(JSON.stringify(req));
+  });
+}
+
+export function startOneBot11Heartbeat(
+  ws: OneBot11WsSocket | undefined,
+  intervalMs: number,
+  existingTimer?: NodeJS.Timeout,
+): NodeJS.Timeout {
+  if (existingTimer) clearInterval(existingTimer);
+  return setInterval(() => {
+    try {
+      ws?.ping?.();
+    } catch {
+      /* ignore */
+    }
+  }, intervalMs);
+}
+
+export function rejectAllPending(
+  pending: Map<string, OneBot11PendingAction>,
+  message = '连接已关闭',
+): void {
+  for (const [, entry] of pending) {
+    clearTimeout(entry.timeout);
+    entry.reject(new Error(message));
+  }
+  pending.clear();
+}

package/src/ws-types.ts

@@ -0,0 +1,21 @@
+/** Minimal WS surface used by the endpoint (real `ws` or test mock). */
+export interface OneBot11WsSocket {
+  readonly readyState: number;
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  ping?(): void;
+  on(event: 'open' | 'message' | 'close' | 'error', listener: (...args: unknown[]) => void): void;
+}
+
+export interface OneBot11WsCreateOptions {
+  readonly headers?: Record<string, string>;
+}
+
+export const WS_OPEN = 1;
+
+export interface OneBot11PendingAction {
+  resolve: (value: OneBot11ActionResponse) => void;
+  reject: (err: Error) => void;
+  timeout: NodeJS.Timeout;
+}
+import type { OneBot11ActionResponse } from './protocol.js';

package/src/wss-auth.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage } from 'node:http';
+
+export function verifyOneBotAccessToken(
+  accessToken: string | undefined,
+  request: IncomingMessage,
+): boolean {
+  if (!accessToken) return true;
+  const auth = request.headers.authorization ?? '';
+  if (auth === `Bearer ${accessToken}`) return true;
+  try {
+    const url = new URL(request.url ?? '/', 'http://localhost');
+    if (url.searchParams.get('access_token') === accessToken) return true;
+  } catch {
+    /* ignore */
+  }
+  return false;
+}

package/src/wss-endpoint.ts

@@ -0,0 +1,228 @@
+/**
+ * OneBot11 reverse WSS endpoint — accepts inbound WebSocket from OneBot implementation.
+ */
+import {
+  ClientEndpoint,
+  createEndpointLifecycle,
+  createRecallEndpointControl,
+  type EndpointLifecycle,
+  type EndpointControl,
+  type EndpointManagement,
+  type EndpointSendRequest,
+} from 'zhin.js/adapter';
+import type { HttpHost, WsConnection } from '@zhin.js/host-http';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import type { CapabilityId } from 'zhin.js';
+import { createOneBot11EndpointManagement } from './endpoint-management.js';
+import {
+  buildSendAction,
+  formatInboundContent,
+  formatInboundMetadata,
+  formatOutboundSegments,
+  isMessageEvent,
+  onebot11InboundConversation,
+  senderDisplayName,
+  senderUserId,
+  type OneBot11Event,
+  type OneBot11WssConfig,
+} from './protocol.js';
+import { receiveOneBot11SideEvent } from './side-event-dispatch.js';
+import { createOneBot11ContentPort } from './content-port.js';
+import { verifyOneBotAccessToken } from './wss-auth.js';
+import {
+  callOneBot11WsAction,
+  handleOneBot11WsMessage,
+  rejectAllPending,
+} from './ws-transport.js';
+import { OneBot11WsEndpoint } from './ws-endpoint.js';
+import {
+  type OneBot11PendingAction,
+  type OneBot11WsSocket,
+} from './ws-types.js';
+import { callOnebot11Client, createOnebot11EndpointClient, forwardOnebot11ClientEvents, type Onebot11Client } from './client.js';
+
+export interface OneBot11WssEndpointOptions {
+  readonly id: CapabilityId;
+  readonly http: HttpHost;
+  readonly config: OneBot11WssConfig;
+}
+
+export class OneBot11WssEndpoint extends ClientEndpoint<Onebot11Client> {
+  readonly client: Onebot11Client;
+  readonly #logger!: ReturnType<typeof getAdapterLogger>;
+
+  readonly #options: OneBot11WssEndpointOptions;
+  readonly management: EndpointManagement;
+  readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
+  readonly content;
+  #ws?: OneBot11WsSocket;
+  #wsRelease?: () => void;
+  readonly #lifecycle: EndpointLifecycle;
+  #requestId = { value: 0 };
+  #pending = new Map<string, OneBot11PendingAction>();
+
+  constructor(options: OneBot11WssEndpointOptions) {
+    super();
+    this.#logger = getAdapterLogger('onebot11', options.config.id);
+    this.#options = options;
+    this.#lifecycle = createEndpointLifecycle({
+      name: options.config.id,
+      reconnect: false,
+      heartbeat: { intervalMs: options.config.heartbeat_interval },
+    });
+    this.client = createOnebot11EndpointClient(options.config, (action, params) => this.#callApi(action, params));
+    const callApi = (action: string, params?: Record<string, unknown>) => callOnebot11Client(this.client, action, params);
+    this.management = createOneBot11EndpointManagement({ callApi });
+    this.content = createOneBot11ContentPort(callApi);
+    this.bindClientEvents(
+      (receive) => forwardOnebot11ClientEvents(this.client, receive),
+      (name, payload) => {
+        if (name === 'event') this.#admitRaw(payload as OneBot11Event);
+      },
+      (_name, error) => this.#warnPlatformEvent(error),
+    );
+  }
+
+  async start(): Promise<void> {
+    if (!this.#options.config.access_token) {
+      // wss 模式未配 access_token 时任何连接都会被放行（verifyOneBotAccessToken 直接 return true）
+      this.#logger.warn(formatCompact({
+        endpoint: this.#options.config.id,
+        mode: 'wss',
+        ok: false,
+        error: 'missing access_token',
+      }));
+    }
+    await this.#lifecycle.start(async (lifecycleHandle) => {
+      const handle = this.#options.http.ws(this.#options.config.path);
+      this.#wsRelease = handle.onConnection((connection) => {
+        this.#acceptConnection(connection);
+      });
+      lifecycleHandle.onForceClose(() => {
+        this.#wsRelease?.();
+        this.#wsRelease = undefined;
+        try {
+          this.#ws?.close();
+        } catch {
+          /* ignore */
+        }
+        this.#ws = undefined;
+      });
+    });
+    this.#logger.info(formatCompact({
+      op: 'listen',
+      endpoint: this.#options.config.id,
+      mode: 'wss',
+      path: this.#options.config.path,
+    }));
+  }
+
+  async stop(): Promise<void> {
+    this.close();
+    await this.#lifecycle.stop();
+    rejectAllPending(this.#pending);
+  }
+
+  async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
+    const message = formatOutboundSegments(payload);
+    const { action, params } = buildSendAction(conversation, message);
+    const data = await callOnebot11Client<{ message_id?: number | string }>(this.client, action, params);
+    return data?.message_id != null ? String(data.message_id) : '';
+  }
+
+  async recallMessage(messageId: string): Promise<void> {
+    if (!messageId) return;
+    await callOnebot11Client(this.client, 'delete_msg', { message_id: Number(messageId) });
+  }
+
+  #callApi(
+    action: string,
+    params: Record<string, unknown> = {},
+  ): ReturnType<typeof callOneBot11WsAction> {
+    return callOneBot11WsAction(this.#ws, this.#pending, this.#requestId, action, params);
+  }
+
+  #admitRaw(ev: OneBot11Event): void {
+    if (!isMessageEvent(ev)) {
+      receiveOneBot11SideEvent(
+        (name, payload) => this.emit(name, payload),
+        this.#options.config.id,
+        { callApi: (action, params) => callOnebot11Client(this.client, action, params) },
+        ev,
+        this.#logger,
+      );
+      return;
+    }
+    const conversation = onebot11InboundConversation(String(this.#options.id), ev);
+    const inbound = formatInboundMetadata(ev, this.#options.config.id);
+    void this.emit('message.receive', {
+      conversation,
+      message: { conversation, id: String(ev.message_id) },
+      content: formatInboundContent(ev),
+      sender: {
+        id: senderUserId(ev),
+        name: senderDisplayName(ev) || undefined,
+        ...(ev.sender?.role ? { roles: [ev.sender.role] } : {}),
+      },
+      endpointId: inbound.endpointId,
+      ...(inbound.mentioned ? { mentioned: true } : {}),
+      ...(inbound.replyTo ? { replyTo: inbound.replyTo } : {}),
+      metadata: inbound.metadata,
+    }).catch((err) => {
+      this.#logger.warn(formatCompact({
+        op: 'onebot11_gateway_receive_failed',
+        target: `${conversation.kind}:${conversation.id}`,
+        error: err instanceof Error ? err.message : String(err),
+      }));
+    });
+  }
+
+  #warnPlatformEvent(error: unknown): void {
+    this.#logger.warn(formatCompact({
+      op: 'onebot11_platform_event_failed',
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+
+  #acceptConnection(connection: WsConnection): void {
+    if (!verifyOneBotAccessToken(this.#options.config.access_token, connection.request)) {
+      connection.socket.close(4003, 'Unauthorized');
+      return;
+    }
+    const socket = connection.socket as unknown as OneBot11WsSocket;
+    if (this.#ws) {
+      try {
+        this.#ws.close();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.#ws = socket;
+    this.#lifecycle.startHeartbeat(() => {
+      try {
+        this.#ws?.ping?.();
+      } catch {
+        /* ignore */
+      }
+    });
+    socket.on('message', (data) => {
+      this.#lifecycle.notifyHeartbeatAck();
+      handleOneBot11WsMessage(data, {
+        endpointId: this.#options.config.id,
+        pending: this.#pending,
+        ingest: (ev) => this.client.ingest(ev as Parameters<Onebot11Client['ingest']>[0]),
+      });
+    });
+    socket.on('close', () => {
+      if (this.#ws === socket) {
+        this.#ws = undefined;
+        this.#lifecycle.stopHeartbeat();
+      }
+    });
+    this.#logger.debug(formatCompact({
+      endpoint: this.#options.config.id,
+      mode: 'wss',
+      peer: connection.request.socket.remoteAddress,
+    }));
+  }
+}