@zhin.js/adapter-onebot11 1.0.98 → 1.1.2

package/lib/protocol.js

@@ -0,0 +1,327 @@
+/**
+ * OneBot 11 protocol helpers (no legacy Adapter/Endpoint / segment-mapper).
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ * Spec: https://github.com/botuniverse/onebot-11
+ */
+import { isMediaRef } from '@zhin.js/im-contract';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+const logger = getLogger('onebot11');
+function normalizeConnection(connection) {
+    if (connection === 'ws' || connection === 'wss')
+        return connection;
+    return 'ws';
+}
+export function resolveOneBot11Config(config) {
+    const connection = normalizeConnection(config.connection);
+    const id = requiredEndpointField(config.id, 'id');
+    const access_token = optionalEndpointField(config.access_token);
+    if (connection === 'ws') {
+        const url = requiredEndpointField(config.url, 'url');
+        return {
+            context: 'onebot11',
+            connection: 'ws',
+            id,
+            access_token,
+            url,
+            reconnect_interval: config.reconnect_interval ?? 5000,
+            heartbeat_interval: config.heartbeat_interval ?? 30_000,
+        };
+    }
+    if (connection === 'wss') {
+        const path = requiredEndpointField(config.path, 'path');
+        return {
+            context: 'onebot11',
+            connection: 'wss',
+            id,
+            access_token,
+            path,
+            heartbeat_interval: config.heartbeat_interval ?? 30_000,
+        };
+    }
+    throw new TypeError(`Unknown OneBot11 connection: ${String(connection)}`);
+}
+function requiredEndpointField(value, field) {
+    const resolved = optionalEndpointField(value);
+    if (!resolved) {
+        throw new TypeError(`OneBot11 endpoint requires a non-empty ${field}`);
+    }
+    return resolved;
+}
+function optionalEndpointField(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+/** 判断是否为消息事件（post_type=message） */
+export function isMessageEvent(ev) {
+    return ev.post_type === 'message' && ev.message_id != null;
+}
+/** 从事件得到场景 id：私聊 user_id，群 group_id */
+export function getChannelId(ev) {
+    if (ev.message_type === 'group' && ev.group_id != null)
+        return String(ev.group_id);
+    if (ev.group_id != null && ev.message_type !== 'private')
+        return String(ev.group_id);
+    if (ev.user_id != null)
+        return String(ev.user_id);
+    return '';
+}
+/**
+ * 入站归一化 → ConversationRef：OneBot 11 `group` 消息 → kind 'group'，
+ * 其余（private 及带 group_id 的非 private 事件按群处理）→ kind 'private'。
+ * OneBot 11 无 guild/temp 容器概念，不填 parent。
+ */
+export function onebot11InboundConversation(endpointKey, ev) {
+    const kind = ev.message_type === 'group' || (ev.group_id != null && ev.message_type !== 'private')
+        ? 'group'
+        : 'private';
+    return {
+        endpoint: { id: endpointKey, adapter: endpointKey.split('\0')[0] ?? endpointKey },
+        kind,
+        id: getChannelId(ev),
+    };
+}
+/** Build inbound text for OutboundMessageService.receive */
+export function formatInboundContent(ev) {
+    if (Array.isArray(ev.message)) {
+        return ev.message
+            .map((seg) => (seg.type === 'text' ? String(seg.data?.text ?? '') : ''))
+            .join('');
+    }
+    return typeof ev.raw_message === 'string'
+        ? stripCqCodes(ev.raw_message).trim()
+        : '';
+}
+function stripCqCodes(input) {
+    let result = '';
+    let cursor = 0;
+    while (cursor < input.length) {
+        const start = input.indexOf('[CQ:', cursor);
+        if (start < 0)
+            return result + input.slice(cursor);
+        result += input.slice(cursor, start);
+        const end = input.indexOf(']', start + 4);
+        if (end < 0)
+            return result + input.slice(start);
+        cursor = end + 1;
+    }
+    return result;
+}
+export function senderDisplayName(ev) {
+    const name = ev.sender?.card || ev.sender?.nickname;
+    if (typeof name === 'string' && name)
+        return name;
+    return ev.user_id != null ? String(ev.user_id) : '';
+}
+/**
+ * Runtime Message.sender 必须是用户 ID（agent bridge 用它与 endpointMaster 比对）。
+ * user_id 缺失时兜底为空串，绝不回退到显示名。
+ */
+export function senderUserId(ev) {
+    return ev.user_id != null ? String(ev.user_id) : '';
+}
+/** 显示名（群名片优先）放 metadata.nickname；没有则返回 undefined，不写该字段。 */
+export function senderNickname(ev) {
+    const name = ev.sender?.card || ev.sender?.nickname;
+    return typeof name === 'string' && name ? name : undefined;
+}
+/**
+ * 回复引用 id：优先取 message 数组中的 {type:'reply', data:{id}} 段；
+ * 兼容部分实现把 reply 放在事件顶层（标量或带 message_id 的对象）。
+ */
+export function extractQuoteId(ev) {
+    if (Array.isArray(ev.message)) {
+        for (const seg of ev.message) {
+            if (seg?.type === 'reply' && seg.data?.id != null)
+                return String(seg.data.id);
+        }
+    }
+    const reply = ev.reply;
+    if (typeof reply === 'number' || typeof reply === 'string')
+        return String(reply);
+    if (reply && typeof reply === 'object' && 'message_id' in reply) {
+        const id = reply.message_id;
+        if (id != null)
+            return String(id);
+    }
+    return undefined;
+}
+/** 扫描 message 段中的 at，qq 等于本机 uin（self_id）即视为被 @；`qq:'all'`（@全体）不算。 */
+export function isOneBot11BotMentioned(input) {
+    if (!input.selfId || !Array.isArray(input.message))
+        return false;
+    return input.message.some((seg) => {
+        if (seg?.type !== 'at' || seg.data?.qq == null)
+            return false;
+        const qq = String(seg.data.qq);
+        return qq !== 'all' && qq === input.selfId;
+    });
+}
+/** 构造 gateway.receive 的 metadata 与提升字段（ws / wss 两个 endpoint 共用）。 */
+export function formatInboundMetadata(ev, endpoint) {
+    const selfId = ev.self_id != null ? String(ev.self_id) : undefined;
+    const nickname = senderNickname(ev);
+    const quoteId = extractQuoteId(ev);
+    const mentioned = isOneBot11BotMentioned({ selfId, message: ev.message });
+    return {
+        metadata: Object.freeze({
+            message_type: ev.message_type,
+            user_id: ev.user_id != null ? String(ev.user_id) : undefined,
+            group_id: ev.group_id != null ? String(ev.group_id) : undefined,
+            time: ev.time,
+            self_id: selfId,
+            role: ev.sender?.role,
+            ...(nickname ? { nickname } : {}),
+        }),
+        endpointId: endpoint,
+        mentioned,
+        replyTo: quoteId ? { id: quoteId } : undefined,
+    };
+}
+/**
+ * canonical MediaRef → OneBot `file` 参数：url 直传、base64 → `base64://`、
+ * 本地路径 → `file://`（路径在 OneBot 实现侧解析）、kind=file 不透明引用原样透传。
+ */
+export function mediaRefToOneBotFile(media) {
+    if (media.kind === 'base64') {
+        return media.value.startsWith('base64://') ? media.value : `base64://${media.value}`;
+    }
+    if (media.kind === 'path') {
+        return media.value.startsWith('file://') ? media.value : `file://${media.value}`;
+    }
+    return media.value;
+}
+/** 媒体段 data 里的 canonical-only 字段，不进 OneBot wire。 */
+const MEDIA_DATA_SKIP_KEYS = new Set(['media', 'alt']);
+/**
+ * image / record / video 段：只消费 canonical `data.media` MediaRef，
+ * 映射为 OneBot `file` 参数；无 MediaRef 时 warn + 丢弃（返回 null）。
+ */
+function oneBotMediaSegment(type, data) {
+    if (!isMediaRef(data.media)) {
+        logger.warn(formatCompact({
+            op: 'onebot11_outbound_media_dropped',
+            type,
+            reason: 'missing_media_ref',
+        }));
+        return null;
+    }
+    const extra = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (!MEDIA_DATA_SKIP_KEYS.has(key))
+            extra[key] = value;
+    }
+    return { type, data: { ...extra, file: mediaRefToOneBotFile(data.media) } };
+}
+/**
+ * canonical Segment → OneBot 11 数组段：
+ * - mention → at（`qq: target`）；
+ * - reply（`message_id`）→ reply（`id`）；
+ * - image / audio→record / video 的 MediaRef → `file`（url / base64:// / file:// / 不透明引用）；
+ * - file 段无 OneBot 11 消息段承载（文件走 upload_*_file API），warn + 丢弃；
+ * - face 取 `id`；
+ * - 其余（已是 wire 形状的段、平台扩展段）原样透传。
+ * 返回 null 表示该段被丢弃。
+ */
+function canonicalToOneBotSegment(segment) {
+    const data = segment.data ?? {};
+    switch (segment.type) {
+        case 'mention': {
+            const target = data.target ?? data.qq ?? data.id;
+            if (target == null)
+                return { type: segment.type, data };
+            return { type: 'at', data: { qq: String(target) } };
+        }
+        case 'reply': {
+            const messageId = data.message_id ?? data.id;
+            if (messageId == null)
+                return { type: segment.type, data };
+            return { type: 'reply', data: { id: String(messageId) } };
+        }
+        case 'face': {
+            if (data.id == null)
+                return { type: segment.type, data };
+            return { type: 'face', data: { id: data.id } };
+        }
+        case 'image':
+        case 'record':
+        case 'video':
+            return oneBotMediaSegment(segment.type, data);
+        case 'audio':
+            return oneBotMediaSegment('record', data);
+        case 'file':
+            logger.warn(formatCompact({
+                op: 'onebot11_outbound_media_dropped',
+                type: 'file',
+                reason: 'file_segment_not_supported',
+            }));
+            return null;
+        default:
+            return { type: segment.type, data };
+    }
+}
+/**
+ * Wire-encode an already-rendered outbound payload into OneBot 11 message segments.
+ * 入参假定已经 core `normalizeOutboundPayload` 归一为 canonical Segment[]；
+ * 媒体段只消费 canonical `data.media`（无 MediaRef 的媒体段 warn + 丢弃），
+ * 其余 wire 形状段（at / 平台扩展段）原样透传。
+ */
+export function formatOutboundSegments(payload) {
+    if (typeof payload === 'string') {
+        return [{ type: 'text', data: { text: payload } }];
+    }
+    const items = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === 'object' && 'type' in payload
+            ? [payload]
+            : [];
+    if (items.length === 0) {
+        const text = payload == null
+            ? ''
+            : typeof payload === 'object'
+                ? JSON.stringify(payload)
+                : String(payload);
+        return [{ type: 'text', data: { text } }];
+    }
+    const segs = [];
+    for (const item of items) {
+        if (typeof item === 'string') {
+            segs.push({ type: 'text', data: { text: item } });
+            continue;
+        }
+        const seg = canonicalToOneBotSegment(item);
+        if (seg)
+            segs.push(seg);
+    }
+    return segs.length ? segs : [{ type: 'text', data: { text: '' } }];
+}
+export function buildSendAction(conversation, message) {
+    if (conversation.kind === 'group') {
+        return {
+            action: 'send_group_msg',
+            params: {
+                group_id: Number(conversation.id) || conversation.id,
+                message,
+            },
+        };
+    }
+    return {
+        action: 'send_private_msg',
+        params: {
+            user_id: Number(conversation.id) || conversation.id,
+            message,
+        },
+    };
+}
+/** Build WS connect URL + headers (access_token via Bearer + query). */
+export function buildWsConnectOptions(config) {
+    const headers = {};
+    let connectUrl = config.url;
+    if (config.access_token) {
+        headers.Authorization = `Bearer ${config.access_token}`;
+        const url = new URL(config.url);
+        url.searchParams.set('access_token', config.access_token);
+        connectUrl = url.toString();
+    }
+    const safeUrl = new URL(connectUrl);
+    safeUrl.searchParams.delete('access_token');
+    return { url: connectUrl, headers, safeUrl: safeUrl.toString() };
+}

package/lib/side-event-dispatch.d.ts

@@ -0,0 +1,7 @@
+import type { EndpointEventEmitter } from 'zhin.js/adapter';
+import { 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 declare function receiveOneBot11SideEvent(emit: EndpointEventEmitter, endpointKey: string, caller: OneBot11SideEventCaller, raw: OneBot11Event, logger: ReturnType<typeof getAdapterLogger>): void;

package/lib/side-event-dispatch.js

@@ -0,0 +1,36 @@
+import { receiveOneBotLikeSideEvent } from '@zhin.js/core';
+import { formatCompact } from '@zhin.js/logger';
+export function receiveOneBot11SideEvent(emit, endpointKey, caller, raw, logger) {
+    if (!emit)
+        return;
+    const record = raw;
+    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/lib/ws-endpoint.d.ts

@@ -0,0 +1,22 @@
+import { ClientEndpoint, type EndpointControl, type EndpointManagement, type EndpointSendRequest } from 'zhin.js/adapter';
+import type { CapabilityId } from 'zhin.js';
+import { type OneBot11WsConfig } from './protocol.js';
+import { type OneBot11WsCreateOptions, type OneBot11WsSocket } from './ws-types.js';
+import { type Onebot11Client } from './client.js';
+export interface OneBot11WsEndpointOptions {
+    readonly id: CapabilityId;
+    readonly config: OneBot11WsConfig;
+    readonly createWebSocket?: (url: string, options: OneBot11WsCreateOptions) => OneBot11WsSocket;
+}
+export declare class OneBot11WsEndpoint extends ClientEndpoint<Onebot11Client> {
+    #private;
+    readonly client: Onebot11Client;
+    readonly management: EndpointManagement;
+    readonly control: EndpointControl;
+    readonly content: import("@zhin.js/adapter").EndpointContentPort;
+    constructor(options: OneBot11WsEndpointOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    recallMessage(messageId: string): Promise<void>;
+}

package/lib/ws-endpoint.js

@@ -0,0 +1,209 @@
+/**
+ * OneBot11 WS client endpoint — outbound connect to OneBot implementation.
+ */
+import WebSocket from 'ws';
+import { ClientEndpoint, createRecallEndpointControl, createEndpointLifecycle, } from 'zhin.js/adapter';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import { createOneBot11EndpointManagement } from './endpoint-management.js';
+import { buildSendAction, buildWsConnectOptions, formatInboundContent, formatInboundMetadata, formatOutboundSegments, isMessageEvent, onebot11InboundConversation, senderDisplayName, senderUserId, } 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 { callOnebot11Client, createOnebot11EndpointClient, forwardOnebot11ClientEvents } from './client.js';
+export class OneBot11WsEndpoint extends ClientEndpoint {
+    client;
+    #logger;
+    #options;
+    management;
+    control = createRecallEndpointControl((id) => this.recallMessage(id));
+    content;
+    #lifecycle;
+    #ws;
+    #requestId = { value: 0 };
+    #pending = new Map();
+    constructor(options) {
+        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, params) => 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);
+        }, (_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() {
+        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() {
+        this.close();
+        // 基座负责：清重连/心跳定时器、强关 ws、唤醒 stop-during-connect 竞态
+        await this.#lifecycle.stop();
+        rejectAllPending(this.#pending);
+        this.#ws = undefined;
+    }
+    async send({ conversation, payload }) {
+        const message = formatOutboundSegments(payload);
+        const { action, params } = buildSendAction(conversation, message);
+        const data = await callOnebot11Client(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) {
+        if (!messageId)
+            return;
+        await callOnebot11Client(this.client, 'delete_msg', { message_id: Number(messageId) });
+    }
+    #callApi(action, params = {}) {
+        return callOneBot11WsAction(this.#ws, this.#pending, this.#requestId, action, params);
+    }
+    #admitRaw(ev) {
+        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) {
+        this.#logger.warn(formatCompact({
+            op: 'onebot11_platform_event_failed',
+            error: error instanceof Error ? error.message : String(error),
+        }));
+    }
+    async #connect(handle) {
+        const { url, headers, safeUrl } = buildWsConnectOptions(this.#options.config);
+        const create = this.#options.createWebSocket
+            ?? ((connectUrl, options) => new WebSocket(connectUrl, { headers: options.headers }));
+        await new Promise((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),
+                });
+            });
+            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/lib/ws-transport.d.ts

@@ -0,0 +1,12 @@
+import { type OneBot11ActionResponse, type OneBot11Event } from './protocol.js';
+import { type OneBot11PendingAction, type OneBot11WsSocket } from './ws-types.js';
+export declare function decodeWsPayload(data: unknown): string;
+export declare function handleOneBot11WsMessage(data: unknown, options: {
+    readonly endpointId: string;
+    readonly pending: Map<string, OneBot11PendingAction>;
+    readonly ingest: (ev: OneBot11Event) => void;
+}): void;
+export declare function callOneBot11WsAction(ws: OneBot11WsSocket | undefined, pending: Map<string, OneBot11PendingAction>, requestId: {
+    value: number;
+}, action: string, params: Record<string, unknown>): Promise<OneBot11ActionResponse>;
+export declare function rejectAllPending(pending: Map<string, OneBot11PendingAction>, message?: string): void;

package/lib/ws-transport.js

@@ -0,0 +1,59 @@
+import { clearTimeout, setTimeout } from 'node:timers';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { WS_OPEN, } from './ws-types.js';
+const logger = getLogger('onebot11');
+export function decodeWsPayload(data) {
+    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, options) {
+    try {
+        const raw = decodeWsPayload(data);
+        const msg = JSON.parse(raw);
+        if ('echo' in msg && typeof msg.echo === 'string') {
+            const resp = msg;
+            const pending = options.pending.get(resp.echo);
+            if (pending) {
+                options.pending.delete(resp.echo);
+                clearTimeout(pending.timeout);
+                pending.resolve(resp);
+            }
+            return;
+        }
+        options.ingest(msg);
+    }
+    catch (error) {
+        logger.warn(formatCompact({
+            op: 'onebot11_parse_failed',
+            endpoint: options.endpointId,
+            error: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+export function callOneBot11WsAction(ws, pending, requestId, action, params) {
+    if (!ws || ws.readyState !== WS_OPEN) {
+        return Promise.reject(new Error('WebSocket 未连接'));
+    }
+    const echo = `ob11_${++requestId.value}`;
+    const req = { 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 rejectAllPending(pending, message = '连接已关闭') {
+    for (const [, entry] of pending) {
+        clearTimeout(entry.timeout);
+        entry.reject(new Error(message));
+    }
+    pending.clear();
+}