@zhin.js/adapter-napcat 1.1.17 → 1.1.19

package/src/identity.ts

@@ -0,0 +1,29 @@
+import WebSocket from 'ws';
+import { buildWsConnectOptions, readNapCatActionResponse, type NapCatWsConfig } from './protocol.js';
+import { createNapCatRpc } from './ws-transport.js';
+
+/** Separate read-only connection: never changes credentials or state of the running Endpoint. */
+export async function probeNapcatIdentity(config: NapCatWsConfig, signal: AbortSignal): Promise<string | undefined> {
+  signal.throwIfAborted();
+  const { url, headers } = buildWsConnectOptions(config);
+  const socket = new WebSocket(url, { headers });
+  const rpc = createNapCatRpc({ endpointId: config.id, signal, socket: () => socket });
+  let rejectOpen: (error: unknown) => void = () => undefined;
+  const abort = () => { rejectOpen(signal.reason); rpc.disconnect(); socket.terminate(); };
+  signal.addEventListener('abort', abort, { once: true });
+  socket.on('message', data => rpc.receive(data, () => undefined));
+  socket.on('close', () => { rejectOpen(new Error('Identity connection closed')); rpc.disconnect(); });
+  try {
+    await new Promise<void>((resolve, reject) => { rejectOpen = reject; socket.once('open', resolve); socket.on('error', reject); });
+    signal.throwIfAborted();
+    const response = await rpc.call({ action: 'get_login_info', signal });
+    readNapCatActionResponse(response);
+    signal.throwIfAborted();
+    const data: unknown = response.data;
+    if (!data || typeof data !== 'object' || !('user_id' in data)
+      || (typeof data.user_id !== 'string' && typeof data.user_id !== 'number') || !String(data.user_id).trim() || String(data.user_id) === '0') return undefined;
+    return `qq:${data.user_id}`;
+  } finally {
+    signal.removeEventListener('abort', abort); rpc.dispose(); socket.terminate();
+  }
+}

package/src/index.ts

@@ -27,6 +27,7 @@ export {
   type ParsedSendTarget,
   type ResolvedNapCatConfig,
 } from './protocol.js';
+export { NapcatAdapter } from './adapter.js';
 
 export {
   InboundMessageDeduper,
@@ -36,9 +37,13 @@ export {
 } from './napcat-inbound.js';
 
 export {
-  napcatClient,
   type NapcatClient,
   type NapcatClientEventMap,
+  type NapcatClientOptions,
+  type NapcatMemberTitleRequest,
+  type NapcatProfileRequest,
+  type NapcatGroupFileRequest,
+  type NapcatMiniAppRequest,
 } from './client.js';
 
 export { parseOneBotGetMsgResponse } from './onebot-get-msg.js';
@@ -61,11 +66,10 @@ export {
 export type { NapCatWsSocket, NapCatWsCreateOptions } from './ws-types.js';
 
 export {
-  callNapCatWsAction,
+  createNapCatRpc,
   decodeWsPayload,
-  handleNapCatWsMessage,
-  rejectAllPending,
-  startNapCatHeartbeat,
+  type NapCatRpc,
+  type NapCatRpcOptions,
 } from './ws-transport.js';
 
 export { verifyNapCatAccessToken } from './wss-auth.js';

package/src/onebot-get-msg.ts

@@ -39,7 +39,7 @@ export function parseOneBotGetMsgResponse(
 }
 
 export function createNapCatContentPort(
-  callApi: (action: string, params?: Record<string, unknown>) => Promise<unknown>,
+  callApi: (request: PendingRpcRequest) => Promise<unknown>,
 ): EndpointContentPort {
   return Object.freeze({
     async resolve(reference: ConversationReference, context: EndpointContentResolveContext) {
@@ -51,7 +51,7 @@ export function createNapCatContentPort(
             : Object.freeze({ status: 'resolved' as const, reference, value: reference.media });
         }
         if (reference.kind === 'message') {
-          const parsed = parseOneBotGetMsgResponse(reference.message.id, await callApi('get_msg', { message_id: reference.message.id }));
+          const parsed = parseOneBotGetMsgResponse(reference.message.id, await callApi({ action: 'get_msg', params: { message_id: reference.message.id }, signal: context.signal }));
           context.signal.throwIfAborted();
           const value: ConversationMessage = Object.freeze({
             ref: reference.message,
@@ -61,7 +61,7 @@ export function createNapCatContentPort(
           });
           return Object.freeze({ status: 'resolved' as const, reference, value });
         }
-        const raw = await callApi('get_forward_msg', { message_id: reference.forwardId, id: reference.forwardId }) as Record<string, unknown>;
+        const raw = await callApi({ action: 'get_forward_msg', params: { message_id: reference.forwardId, id: reference.forwardId }, signal: context.signal }) as Record<string, unknown>;
         context.signal.throwIfAborted();
         const nodes = Array.isArray(raw.messages) ? raw.messages.slice(0, context.maxEntries) : [];
         const value: readonly ForwardEntry[] = Object.freeze(nodes.map((node) => {
@@ -93,5 +93,5 @@ function toMillis(value: unknown): number {
   const time = Number(value);
   return Number.isFinite(time) ? (time < 10_000_000_000 ? time * 1000 : time) : Date.now();
 }
-import type { EndpointContentPort, EndpointContentResolveContext } from 'zhin.js/adapter';
+import type { PendingRpcRequest, EndpointContentPort, EndpointContentResolveContext } from 'zhin.js/adapter';
 import type { ConversationMessage, ConversationReference, ForwardEntry } from '@zhin.js/im-contract';

package/src/protocol.ts

@@ -104,6 +104,22 @@ export interface NapCatActionResponse {
   wording?: string;
 }
 
+/** OneBot 11: async/1 is submitted without a known result, not a rejection.
+ * https://github.com/botuniverse/onebot-11/blob/master/communication/http.md#响应
+ */
+export function readNapCatActionResponse(value: unknown): NapCatActionResponse {
+  if (!value || typeof value !== 'object' || !('status' in value) || !('retcode' in value)
+    || !Number.isInteger(value.retcode)) throw new EndpointDeliveryError('delivery_unconfirmed', 'NapCat returned an invalid action response', 'unknown');
+  const response = value as NapCatActionResponse;
+  if (response.status === 'failed' && response.retcode !== 0 && response.retcode !== 1) {
+    throw new EndpointDeliveryError('platform_rejected',
+      `NapCat action failed [${response.retcode}]: ${response.message || response.wording || 'unknown'}`, 'rejected');
+  }
+  if (response.status !== 'ok' || response.retcode !== 0) throw new EndpointDeliveryError('delivery_unconfirmed',
+    'NapCat did not confirm the action result', 'unknown');
+  return response;
+}
+
 export interface NapCatWireSegment {
   readonly type: string;
   readonly data?: Record<string, unknown>;
@@ -430,6 +446,7 @@ export function buildWsConnectOptions(config: NapCatWsConfig): {
 export interface NapCatHttpOptions {
   readonly http_url: string;
   readonly access_token?: string;
+  readonly signal?: AbortSignal;
 }
 
 /**
@@ -448,24 +465,19 @@ export async function callNapCatHttpAction(
     headers.Authorization = `Bearer ${options.access_token}`;
   }
   const res = await fetch(url, {
-    signal: AbortSignal.timeout(30_000),
+    signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(30_000)]) : AbortSignal.timeout(30_000),
     method: 'POST',
     headers,
     body: JSON.stringify(params),
   });
   const text = await res.text();
-  if (res.status === 401) throw new EndpointDeliveryError('platform_rejected', `NapCat HTTP auth failed: ${text}`, 'rejected');
-  if (res.status !== 200) throw new EndpointDeliveryError(res.status === 429 || res.status === 403 ? 'platform_rejected' : 'delivery_unconfirmed', `NapCat HTTP ${res.status}: ${text}`, res.status === 429 || res.status === 403 ? 'rejected' : 'unknown');
-  let data: NapCatActionResponse;
-  try {
-    data = JSON.parse(text) as NapCatActionResponse;
-  } catch {
-    throw new Error(`NapCat HTTP invalid response: ${text.slice(0, 200)}`);
-  }
-  if (data.status !== 'ok' && data.retcode !== 0) {
-    throw new EndpointDeliveryError(
-      'platform_rejected', `NapCat HTTP action failed [${data.retcode}]: ${data.message || data.wording || 'unknown'}`, 'rejected',
-    );
+  if (res.status !== 200) {
+    const rejected = [400, 401, 403, 404, 406, 429].includes(res.status);
+    throw new EndpointDeliveryError(rejected ? 'platform_rejected' : 'delivery_unconfirmed',
+      `NapCat HTTP ${res.status}: ${text}`, rejected ? 'rejected' : 'unknown');
   }
-  return data;
+  let data: unknown;
+  try { data = JSON.parse(text); }
+  catch (cause) { throw new EndpointDeliveryError('delivery_unconfirmed', 'NapCat returned invalid JSON', 'unknown', { cause }); }
+  return readNapCatActionResponse(data);
 }

package/src/ws-endpoint.ts

@@ -4,7 +4,7 @@ import { EndpointDeliveryError } from '@zhin.js/im-contract';
  */
 import WebSocket from 'ws';
 import {
-  Endpoint,
+  createEndpointSpecification, endpointSpec, type Endpoint, type EndpointSpecification,
   createRecallEndpointControl,
   createEndpointLifecycle,
   type EndpointConnectHandle,
@@ -38,12 +38,6 @@ import {
 } from './protocol.js';
 import { receiveNapCatSideEvent } from './side-event-dispatch.js';
 import {
-  callNapCatWsAction,
-  handleNapCatWsMessage,
-  rejectAllPending,
-} from './ws-transport.js';
-import {
-  type NapCatPendingAction,
   type NapCatWsCreateOptions,
   type NapCatWsSocket,
 } from './ws-types.js';
@@ -52,6 +46,7 @@ import { NapcatClient } from './client.js';
 
 export interface NapCatWsEndpointOptions {
   readonly id: CapabilityId;
+  readonly signal?: AbortSignal;
   readonly config: NapCatWsConfig;
   readonly createWebSocket?: (
     url: string,
@@ -59,25 +54,36 @@ export interface NapCatWsEndpointOptions {
   ) => NapCatWsSocket;
 }
 
-export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
-  readonly client = new NapcatClient((action, params) => this.#callApi(action, params));
+export class NapCatWsEndpoint extends NapcatClient implements Endpoint {
+  readonly [endpointSpec]: EndpointSpecification;
   readonly #logger!: ReturnType<typeof getAdapterLogger>;
 
   readonly #options: NapCatWsEndpointOptions;
   readonly #inboundDeduper = new InboundMessageDeduper();
-  readonly management: EndpointManagement = createNapCatEndpointManagement(this.client);
-  readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
-  readonly content = createNapCatContentPort((action, params) => this.client.callApi(action, params));
+  readonly #management: EndpointManagement = createNapCatEndpointManagement(this);
+  readonly #control: EndpointControl = createRecallEndpointControl((id, signal) => this.#recallMessage(id, signal));
+  readonly #content = createNapCatContentPort(request => this.requestApi(request));
   readonly #lifecycle: EndpointLifecycle;
-  #ws?: NapCatWsSocket;
-  #requestId = { value: 0 };
-  #pending = new Map<string, NapCatPendingAction>();
   #open = false;
 
   constructor(options: NapCatWsEndpointOptions) {
-    super();
+    super({ config: options.config, signal: options.signal });
     this.#logger = getAdapterLogger('napcat', options.config.id);
     this.#options = options;
+    const readTransportState = () => this.#transportState;
+    this[endpointSpec] = createEndpointSpecification(this, {
+      name: options.config.id,
+      start: () => this.#start(), open: () => this.#openEndpoint(),
+      close: () => this.#close(), stop: () => this.#stop(),
+      send: request => this.#send(request),
+      management: this.#management, control: this.#control, content: this.#content,
+      get transportState() { return readTransportState(); },
+    });
+    this.on('event', event => {
+      void this[endpointSpec].events.run(() => this.#admit(event)).catch((error: unknown) => {
+        this.#logger.debug(formatCompact({ op: 'napcat_receive_failed', error: error instanceof Error ? error.message : String(error) }));
+      });
+    });
     this.#lifecycle = createEndpointLifecycle({
       name: options.config.id,
       heartbeat: { intervalMs: options.config.heartbeat_interval, watchdogMisses: 2 },
@@ -91,42 +97,46 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
     });
   }
 
-  get transportState(): EndpointTransportState {
+  get #transportState(): EndpointTransportState {
     return this.#lifecycle.state;
   }
 
-  async start(): Promise<void> {
+  protected override get actionSocket(): NapCatWsSocket | undefined {
+    return this.#lifecycle.state === 'open' ? this.transportSocket : undefined;
+  }
+
+  async #start(): Promise<void> {
     if (this.#lifecycle.started) return;
     await this.#lifecycle.start((handle) => this.#connect(handle));
   }
 
-  open(): void {
+  #openEndpoint(): void {
     this.#open = true;
   }
 
-  close(): void {
+  #close(): void {
     this.#open = false;
   }
 
-  async stop(): Promise<void> {
+  async #stop(): Promise<void> {
     this.#open = false;
     await this.#lifecycle.stop();
-    rejectAllPending(this.#pending);
+    this.rpc.disconnect();
     this.#inboundDeduper.clear();
-    if (this.#ws) {
+    if (this.transportSocket) {
       try {
-        this.#ws.close();
+        this.transportSocket.close();
       } catch {
         /* ignore */
       }
-      this.#ws = undefined;
+      this.transportSocket = undefined;
     }
   }
 
-  async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
+  async #send({ conversation, payload, signal }: EndpointSendRequest): Promise<string> {
     const message = formatOutboundSegments(payload);
     const { action, params } = buildSendAction(napcatOutboundTarget(conversation), message);
-    const data = await this.client.callApi(action, params) as { message_id?: number | string } | undefined;
+    const data = await this.requestApi({ action, params, signal }) as { message_id?: number | string } | undefined;
     const rawId = data?.message_id;
     if ((typeof rawId !== 'number' && typeof rawId !== 'string') || String(rawId).trim() === '' || (typeof rawId === 'number' && !Number.isFinite(rawId))) {
       throw new EndpointDeliveryError('delivery_unconfirmed', 'Message delivery is unconfirmed: platform returned no message_id', 'unknown');
@@ -141,19 +151,18 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
     return messageId;
   }
 
-  async recallMessage(messageId: string): Promise<void> {
+  async #recallMessage(messageId: string, signal?: AbortSignal): Promise<void> {
     if (!messageId) return;
-    await this.client.callApi('delete_msg', { message_id: Number(messageId) });
+    await this.requestApi({ action: 'delete_msg', params: { message_id: Number(messageId) }, signal });
   }
 
-  #callApi(action: string, params: Record<string, unknown> = {}): Promise<unknown> {
-    return callNapCatWsAction(this.#lifecycle.state === 'open' ? this.#ws : undefined, this.#pending, this.#requestId, action, params);
-  }
+
 
   /** Test / internal: admit a parsed event when the endpoint is open. */
-  admit(ev: NapCatEvent): void {
-    if (!this.#open) return;
-    void this.emitPlatform(napCatPlatformEventName(ev), ev).catch((error) => {
+  #admit(ev: NapCatEvent): void {
+    const nativeEvent = ev;
+    if (!this.#open && !this.#lifecycle.started) return;
+    void this[endpointSpec].events.platform(napCatPlatformEventName(ev), ev).catch((error) => {
       this.#logger.warn(formatCompact({
         op: 'napcat_platform_event_failed',
         error: error instanceof Error ? error.message : String(error),
@@ -161,9 +170,9 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
     });
     if (!isMessageEvent(ev)) {
       receiveNapCatSideEvent(
-        (name, payload) => this.emit(name, payload),
+        (name, payload) => this[endpointSpec].events.emit(name, payload),
         this.#options.config.id,
-        this.client,
+        this,
         ev,
         this.#logger,
       );
@@ -175,11 +184,13 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
     if (Array.isArray(ev.message) || typeof ev.message === 'string') {
       ev = { ...ev, message: normalizeMessage(ev.message) };
     }
-    const conversation = napcatInboundConversation(String(this.#options.id), ev);
+    const conversation = { ...napcatInboundConversation(String(this.#options.id), ev), endpoint: this[endpointSpec].identity };
     const content = formatInboundContent(ev);
     const nickname = senderNickname(ev);
     const mentioned = isNapCatBotMentioned(ev);
-    void this.emit('message.receive', {
+    void this[endpointSpec].events.message({
+      event: nativeEvent,
+      ...(typeof nativeEvent.time === 'number' ? { platformSentAt: nativeEvent.time * 1000 } : {}),
       conversation,
       message: { conversation, id: msgId },
       content,
@@ -217,10 +228,10 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
     await new Promise<void>((resolve, reject) => {
       let settled = false;
       const ws = create(url, { headers });
-      this.#ws = ws;
+      this.transportSocket = ws;
       handle.onForceClose(() => {
-        if (this.#ws === ws) {
-          rejectAllPending(this.#pending);
+        if (this.transportSocket === ws) {
+          this.rpc.disconnect();
         }
         try {
           ws.close();
@@ -230,7 +241,7 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
       });
 
       ws.on('open', () => {
-        if (settled || this.#ws !== ws || !this.#lifecycle.started) return;
+        if (settled || this.transportSocket !== ws || !this.#lifecycle.started) return;
         settled = true;
         if (!this.#options.config.access_token) {
           this.#logger.warn(formatCompact({
@@ -258,22 +269,18 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
       });
 
       ws.on('pong', () => {
-        if (this.#ws === ws) this.#lifecycle.notifyHeartbeatAck();
+        if (this.transportSocket === ws) this.#lifecycle.notifyHeartbeatAck();
       });
       ws.on('message', (data) => {
-        if (this.#ws !== ws || ws.readyState !== 1 || !this.#lifecycle.started) return;
+        if (this.transportSocket !== ws || ws.readyState !== 1 || !this.#lifecycle.started) return;
         this.#lifecycle.notifyHeartbeatAck();
-        handleNapCatWsMessage(data, {
-          endpointId: this.#options.config.id,
-          pending: this.#pending,
-          admit: (event) => this.admit(event),
-        });
+        this.rpc.receive(data, event => this.ingest(event));
       });
 
       ws.on('close', (code, reason) => {
-        if (this.#ws !== ws) return;
-        this.#ws = undefined;
-        rejectAllPending(this.#pending);
+        if (this.transportSocket !== ws) return;
+        this.transportSocket = undefined;
+        this.rpc.disconnect();
         const reasonStr = typeof reason === 'string'
           ? reason
           : Buffer.isBuffer(reason)
@@ -300,7 +307,7 @@ export class NapCatWsEndpoint extends Endpoint<NapcatClient> {
       });
 
       ws.on('error', (err) => {
-        if (this.#ws !== ws) return;
+        if (this.transportSocket !== ws) return;
         const error = err instanceof Error ? err : new Error(String(err));
         this.#logger.warn(formatCompact({
           op: 'ws_error',

package/src/ws-transport.ts

@@ -1,112 +1,51 @@
-import { EndpointDeliveryError } from '@zhin.js/im-contract';
-import { clearInterval, clearTimeout, setInterval, setTimeout } from 'node:timers';
+import { createPendingRpc, type PendingRpc, type PendingRpcRequest } from 'zhin.js/adapter';
 import { formatCompact, getLogger } from '@zhin.js/logger';
-import {
-  type NapCatActionRequest,
-  type NapCatActionResponse,
-  type NapCatEvent,
-} from './protocol.js';
-import {
-  WS_OPEN,
-  type NapCatPendingAction,
-  type NapCatWsSocket,
-} from './ws-types.js';
+import type { NapCatActionResponse, NapCatEvent } from './protocol.js';
+import { WS_OPEN, type NapCatWsSocket } from './ws-types.js';
 
 const logger = getLogger('napcat');
-
-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 interface NapCatRpcOptions {
+  readonly endpointId: string;
+  readonly signal?: AbortSignal;
+  /** Reads the lifecycle-selected socket; RPC does not open or reconnect it. */
+  readonly socket: () => NapCatWsSocket | undefined;
+}
+export interface NapCatRpc {
+  call(request: PendingRpcRequest): Promise<NapCatActionResponse>;
+  receive(data: unknown, ingest: (event: NapCatEvent) => void): void;
+  disconnect: PendingRpc<NapCatActionResponse>['disconnect'];
+  dispose(): void;
+  readonly pendingCount: number;
 }
 
-export function handleNapCatWsMessage(
-  data: unknown,
-  options: {
-    readonly endpointId: string;
-    readonly pending: Map<string, NapCatPendingAction>;
-    readonly admit: (ev: NapCatEvent) => void;
-  },
-): void {
-  try {
-    const raw = decodeWsPayload(data);
-    const msg = JSON.parse(raw) as NapCatEvent | NapCatActionResponse;
-    if ('echo' in msg && typeof (msg as NapCatActionResponse).echo === 'string') {
-      const resp = msg as NapCatActionResponse;
-      const pending = options.pending.get(resp.echo!);
-      if (pending) {
-        options.pending.delete(resp.echo!);
-        clearTimeout(pending.timeout);
-        if (resp.status === 'ok') pending.resolve(resp.data);
-        else {
-          pending.reject(new EndpointDeliveryError(
-            'platform_rejected', `API error [${resp.retcode}]: ${resp.message || resp.wording || 'unknown'}`, 'rejected',
-          ));
+/** Native SDK and semantic ports share this Client's correlation and cancellation owner. */
+export function createNapCatRpc(options: NapCatRpcOptions): NapCatRpc {
+  const pending = createPendingRpc<NapCatActionResponse>({
+    signal: options.signal, requestPrefix: 'req_', timeoutMs: 30_000,
+    transport: () => { const socket = options.socket(); return socket?.readyState === WS_OPEN ? socket : undefined; },
+    serialize: request => JSON.stringify({ action: request.action, params: request.params ?? {}, echo: request.id }),
+  });
+  return Object.freeze({
+    call: pending.call, disconnect: pending.disconnect, dispose: pending.dispose,
+    get pendingCount() { return pending.pendingCount; },
+    receive(data: unknown, ingest: (event: NapCatEvent) => void) {
+      try {
+        const message = JSON.parse(decodeWsPayload(data)) as NapCatEvent | NapCatActionResponse;
+        if ('echo' in message && typeof message.echo === 'string') {
+          pending.accept({ id: message.echo, value: message as NapCatActionResponse }); return;
         }
+        ingest(message as NapCatEvent);
+      } catch (error) {
+        logger.warn(formatCompact({ op: 'napcat_parse_failed', endpoint: options.endpointId,
+          error: error instanceof Error ? error.message : String(error) }));
       }
-      return;
-    }
-    options.admit(msg as NapCatEvent);
-  } catch (error) {
-    logger.warn(formatCompact({
-      op: 'napcat_parse_failed',
-      endpoint: options.endpointId,
-      error: error instanceof Error ? error.message : String(error),
-    }));
-  }
-}
-
-export function callNapCatWsAction(
-  ws: NapCatWsSocket | undefined,
-  pending: Map<string, NapCatPendingAction>,
-  requestId: { value: number },
-  action: string,
-  params: Record<string, unknown>,
-): Promise<unknown> {
-  if (!ws || ws.readyState !== WS_OPEN) {
-    return Promise.reject(new EndpointDeliveryError('endpoint_disconnected', 'WebSocket is not connected', 'not_sent'));
-  }
-  const echo = `req_${++requestId.value}`;
-  const req: NapCatActionRequest = { action, params, echo };
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      pending.delete(echo);
-      reject(new EndpointDeliveryError('endpoint_timeout', `API call timeout: ${action}`, 'unknown'));
-    }, 30_000);
-    pending.set(echo, { resolve, reject, timeout });
-    try {
-      ws.send(JSON.stringify(req));
-    } catch (error) {
-      pending.delete(echo);
-      clearTimeout(timeout);
-      reject(error instanceof Error ? error : new Error(String(error)));
-    }
+    },
   });
 }
 
-export function startNapCatHeartbeat(
-  ws: NapCatWsSocket | 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, NapCatPendingAction>,
-  message = 'Connection closed',
-): void {
-  for (const [, entry] of pending) {
-    clearTimeout(entry.timeout);
-    entry.reject(new EndpointDeliveryError('endpoint_disconnected', message, 'unknown'));
-  }
-  pending.clear();
+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 ?? '');
 }

package/src/ws-types.ts

@@ -12,9 +12,3 @@ export interface NapCatWsCreateOptions {
 }
 
 export const WS_OPEN = 1;
-
-export interface NapCatPendingAction {
-  resolve: (value: unknown) => void;
-  reject: (err: Error) => void;
-  timeout: NodeJS.Timeout;
-}