@dsbot-channel/onebot 0.0.0-stage → 0.7.1

package/dist/adapter.js

@@ -0,0 +1,1203 @@
+import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { buildListenerHealth, buildStatus } from '@dsbot-channel/core/adapter-status.js';
+import { answerStatus } from '@dsbot-channel/core/adapters/shared/status-route.js';
+import { ForwardLink } from './ws-forward.js';
+import { ReverseLink } from './ws-reverse.js';
+import { ChannelStats, countersOf } from '@dsbot-channel/core/channel-stats.js';
+import { ConfigError } from '@dsbot-channel/core/config.js';
+import { buildEvent, handleProblem } from '@dsbot-channel/core/event-build.js';
+import { ADAPTER_META_MAX_BYTES } from '@dsbot-channel/core/adapter-meta.js';
+export const ONEBOT_PEER_GUIDANCE = 'This is a private OneBot message. Answer it with your reply as usual. If it needs no answer, call no_reply instead of staying silent. If you refuse it, call decline with a short reason.';
+export const ONEBOT_GROUP_GUIDANCE = 'This is a group message from OneBot. Your reply is posted back to that group. If it needs no answer, call no_reply; if you refuse it, call decline with a short reason.';
+export const ONEBOT_STATUS_ROUTE = '/onebot/status';
+export const ONEBOT_DEDUPE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export const ONEBOT_DEDUPE_LIMIT = 100_000;
+export const ONEBOT_CHAIN_TTL_MS = 60 * 60 * 1000;
+export const ONEBOT_CHAIN_LIMIT = 10_000;
+export const ONEBOT_MAX_BODY_BYTES = 1024 * 1024;
+const MEDIA_FOR_SEGMENT = {
+    image: 'image',
+    record: 'voice',
+    video: 'video',
+    file: 'file',
+};
+function idOf(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'string' && value.length > 0)
+        return value;
+    return undefined;
+}
+function segmentText(segments) {
+    if (!Array.isArray(segments))
+        return '';
+    return segments
+        .filter((segment) => segment !== null && typeof segment === 'object' && segment.type === 'text')
+        .map((segment) => String(segment.data?.text ?? ''))
+        .join('');
+}
+function mentionsOf(segments, selfId) {
+    const mentioned = { self: false, others: false, all: false };
+    if (!Array.isArray(segments))
+        return mentioned;
+    for (const segment of segments) {
+        if (segment === null || typeof segment !== 'object')
+            continue;
+        const one = segment;
+        if (one.type !== 'at')
+            continue;
+        const qq = idOf(one.data?.qq);
+        if (qq === undefined)
+            continue;
+        if (qq === 'all')
+            mentioned.all = true;
+        else if (selfId !== undefined && qq === selfId)
+            mentioned.self = true;
+        else
+            mentioned.others = true;
+    }
+    return mentioned;
+}
+function mediaOf(segments) {
+    const media = [];
+    let dropped = 0;
+    if (!Array.isArray(segments))
+        return { media, dropped };
+    for (const segment of segments) {
+        if (segment === null || typeof segment !== 'object')
+            continue;
+        const one = segment;
+        const type = typeof one.type === 'string' ? MEDIA_FOR_SEGMENT[one.type] : undefined;
+        if (type === undefined)
+            continue;
+        const url = typeof one.data?.url === 'string' && one.data.url.length > 0 ? one.data.url : null;
+        const handle = typeof one.data?.file === 'string' && one.data.file.length > 0 ? one.data.file : null;
+        if (url === null && handle === null) {
+            dropped += 1;
+            continue;
+        }
+        const name = type === 'file' ? (typeof one.data?.name === 'string' ? one.data.name : typeof one.data?.file_name === 'string' ? one.data.file_name : undefined) : undefined;
+        media.push({ type, url, handle, ...(name === undefined || name.length === 0 ? {} : { name }) });
+    }
+    return { media, dropped };
+}
+function replyIdOf(segments) {
+    if (!Array.isArray(segments))
+        return undefined;
+    for (const segment of segments) {
+        if (segment === null || typeof segment !== 'object')
+            continue;
+        const one = segment;
+        if (one.type !== 'reply')
+            continue;
+        const id = idOf(one.data?.id);
+        if (id !== undefined)
+            return id;
+    }
+    return undefined;
+}
+function mapOneBotMessage(event, config, chainOf, warn, now = Date.now) {
+    if (event.post_type !== 'message')
+        return undefined;
+    if (event.message_type !== 'group' && event.message_type !== 'private')
+        return undefined;
+    const messageId = idOf(event.message_id);
+    const eventSelf = idOf(event.self_id);
+    if (config.selfId !== undefined && eventSelf !== undefined && eventSelf !== config.selfId) {
+        warn?.(`dsbot-channel: dropped an onebot event for account ${eventSelf}: this adapter answers for ${config.selfId}`);
+        return undefined;
+    }
+    const selfId = config.selfId ?? eventSelf;
+    if (messageId === undefined || selfId === undefined)
+        return undefined;
+    const scope = event.message_type === 'group' ? 'group' : 'c2c';
+    const target = scope === 'group' ? idOf(event.group_id) : idOf(event.user_id);
+    const senderId = idOf(event.user_id);
+    if (target === undefined || senderId === undefined)
+        return undefined;
+    const replyTo = replyIdOf(event.message);
+    const ownKey = `${scope}:${target}:${messageId}`;
+    const chainId = replyTo === undefined ? ownKey : chainOf(replyTo) ?? ownKey;
+    const rawText = segmentText(event.message);
+    const { media, dropped } = mediaOf(event.message);
+    if (dropped > 0) {
+        warn?.(`dsbot-channel: dropped ${dropped} onebot media reference(s) from ${messageId} that carried neither a url nor a file name`);
+    }
+    const nickname = typeof event.sender?.card === 'string' && event.sender.card.length > 0
+        ? event.sender.card
+        : typeof event.sender?.nickname === 'string'
+            ? event.sender.nickname
+            : '';
+    const kind = config.bots.includes(senderId) ? 'bot' : 'person';
+    const body = rawText;
+    const rawMessage = typeof event.raw_message === 'string' ? event.raw_message : '';
+    const payload = {
+        rawMessage,
+        messageType: event.message_type,
+        ...(typeof event.sub_type === 'string' ? { subType: event.sub_type } : {}),
+    };
+    const oversized = Buffer.byteLength(JSON.stringify(payload), 'utf8') > ADAPTER_META_MAX_BYTES;
+    if (oversized) {
+        warn?.(`dsbot-channel: kept the raw payload of onebot message ${messageId} out of the event: it is larger than ${ADAPTER_META_MAX_BYTES} bytes`);
+    }
+    const built = buildEvent({
+        source: { kind: 'onebot', instance: config.channel, peer: target, scope },
+        author: { senderId, kind, personId: null },
+        body: { text: body, media, replyTo: replyTo ?? null },
+        transport: {
+            messageId,
+            timestamp: typeof event.time === 'number' && Number.isFinite(event.time) ? event.time * 1000 : Date.now(),
+            mentioned: mentionsOf(event.message, selfId),
+            isReply: replyTo !== undefined,
+            signature: null,
+        },
+        declared: { nickname, avatar: '' },
+        ...(oversized ? {} : { adapter: payload }),
+    });
+    return {
+        eventKey: ownKey,
+        chainId,
+        sessionKey: `${scope === 'group' ? 'group' : 'peer'}:${target}`,
+        replyTarget: `${scope === 'group' ? 'group' : 'peer'}:${target}`,
+        requestId: messageId,
+        source: built.source,
+        author: built.author,
+        rawText,
+        body: built.body,
+        transport: built.meta.transport,
+        declared: built.meta.declared,
+        adapter: built.meta.adapter,
+        receivedAt: now(),
+    };
+}
+export const ONEBOT_NOTICE_TYPES = [
+    'group_recall',
+    'friend_recall',
+    'group_ban',
+    'group_lift_ban',
+    'group_increase',
+    'group_decrease',
+    'group_admin',
+    'group_upload',
+    'group_card',
+    'notify',
+];
+export const ONEBOT_REQUEST_TYPES = ['friend', 'group'];
+export const ONEBOT_META_TYPES = ['lifecycle', 'heartbeat'];
+/** Folds a wire event type onto the closed set a status and a profile may name; anything else is "other". */
+function eventTypeOf(postType, value) {
+    const text = typeof value === 'string' ? value : '';
+    const known = postType === 'notice'
+        ? ONEBOT_NOTICE_TYPES
+        : postType === 'request'
+            ? ONEBOT_REQUEST_TYPES
+            : postType === 'meta_event'
+                ? ONEBOT_META_TYPES
+                : [];
+    if (known.includes(text))
+        return text;
+    return text.length === 0 ? 'unknown' : 'other';
+}
+/** The class a status counts an event under; undefined for a message, 'unknown' for a post_type we do not read. */
+export function oneBotEventClass(event) {
+    const postType = typeof event.post_type === 'string' ? event.post_type : '';
+    if (postType === 'message')
+        return undefined;
+    if (postType === 'message_sent')
+        return 'message_sent';
+    if (postType === 'notice')
+        return `notice.${eventTypeOf('notice', event.notice_type)}`;
+    if (postType === 'request')
+        return `request.${eventTypeOf('request', event.request_type)}`;
+    if (postType === 'meta_event')
+        return `meta.${eventTypeOf('meta_event', event.meta_event_type)}`;
+    return 'unknown';
+}
+/** One line of peer text, bounded: control characters flattened, whitespace collapsed. */
+function wireText(value, limit = 120) {
+    if (typeof value !== 'string')
+        return '';
+    let out = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code < 0x20 || (code >= 0x7f && code <= 0x9f) ? ' ' : char;
+    }
+    return Array.from(out.replace(/\s+/g, ' ').trim()).slice(0, limit).join('');
+}
+/** A field kept token-shaped, so an event key never carries whitespace or control characters. */
+function tokenPart(value, limit = 48) {
+    const text = typeof value === 'string' ? value : typeof value === 'number' && Number.isFinite(value) ? String(value) : '';
+    return Array.from(text)
+        .map((char) => (/[A-Za-z0-9_.-]/.test(char) ? char : '_'))
+        .join('')
+        .slice(0, limit);
+}
+function summaryOf(event, postType, type, subType, groupId, userId) {
+    const id = (value) => idOf(value) ?? 'unknown';
+    if (postType === 'message_sent') {
+        const kind = typeof event.message_type === 'string' ? event.message_type : 'unknown';
+        return `sent: ${kind} message ${id(event.message_id)} in ${groupId ?? userId ?? 'unknown'}`;
+    }
+    if (postType === 'meta_event') {
+        return `meta: ${type} account ${id(event.self_id)}${subType === undefined ? '' : ` ${subType}`}`;
+    }
+    if (postType === 'request') {
+        const comment = wireText(event.comment);
+        const head = `request: ${type} user ${id(event.user_id)}`;
+        if (type === 'group')
+            return `${head} asked to join group ${groupId ?? 'unknown'}${comment.length === 0 ? '' : `: ${comment}`}`;
+        return `${head} asked to be a friend${comment.length === 0 ? '' : `: ${comment}`}`;
+    }
+    const head = `notice: ${type}`;
+    const who = id(event.user_id);
+    switch (type) {
+        case 'group_recall':
+            return `${head} user ${who} recalled message ${id(event.message_id)} in group ${groupId ?? 'unknown'}`;
+        case 'friend_recall':
+            return `${head} user ${who} recalled a message`;
+        case 'group_ban':
+            return subType === 'lift_ban'
+                ? `${head} operator ${id(event.operator_id)} lifted the ban on user ${who} in group ${groupId ?? 'unknown'}`
+                : `${head} operator ${id(event.operator_id)} banned user ${who} in group ${groupId ?? 'unknown'}`;
+        case 'group_lift_ban':
+            return `${head} operator ${id(event.operator_id)} lifted the ban on user ${who} in group ${groupId ?? 'unknown'}`;
+        case 'group_increase':
+            return `${head} user ${who} joined group ${groupId ?? 'unknown'}`;
+        case 'group_decrease':
+            return `${head} user ${who} left group ${groupId ?? 'unknown'}`;
+        case 'group_admin':
+            return `${head} user ${who} ${subType === 'unset' ? 'lost' : 'gained'} admin in group ${groupId ?? 'unknown'}`;
+        case 'group_upload':
+            return `${head} user ${who} uploaded ${wireText(event.file?.name) || 'a file'} to group ${groupId ?? 'unknown'}`;
+        case 'group_card':
+            return `${head} user ${who} changed card in group ${groupId ?? 'unknown'}`;
+        case 'notify':
+            return `${head} ${subType ?? 'notice'} from user ${who}`;
+        default:
+            return `${head} from user ${who}`;
+    }
+}
+/** Maps a notice, request, meta event or a self echo onto the same inbound shape, marked by kind. */
+function mapOneBotOther(event, config, now) {
+    const postType = typeof event.post_type === 'string' ? event.post_type : '';
+    if (postType !== 'notice' && postType !== 'request' && postType !== 'meta_event' && postType !== 'message_sent') {
+        return undefined;
+    }
+    const selfId = idOf(event.self_id);
+    if (config.selfId !== undefined && selfId !== undefined && selfId !== config.selfId)
+        return undefined;
+    const groupId = idOf(event.group_id);
+    const userId = idOf(event.user_id) ?? idOf(event.target_id) ?? selfId;
+    const observedAt = typeof event.time === 'number' && Number.isFinite(event.time) ? event.time * 1000 : now();
+    const kind = postType === 'meta_event' ? 'meta' : postType === 'request' ? 'request' : 'notice';
+    const type = postType === 'notice'
+        ? eventTypeOf('notice', event.notice_type)
+        : postType === 'request'
+            ? eventTypeOf('request', event.request_type)
+            : postType === 'meta_event'
+                ? eventTypeOf('meta_event', event.meta_event_type)
+                : 'sent';
+    const subType = typeof event.sub_type === 'string' && event.sub_type.length > 0 ? event.sub_type : undefined;
+    const identity = [
+        typeof event.time === 'number' && Number.isFinite(event.time) ? String(event.time) : '',
+        tokenPart(groupId),
+        tokenPart(userId),
+        tokenPart(subType),
+        tokenPart(idOf(event.operator_id)),
+        tokenPart(idOf(event.message_id)),
+        tokenPart(idOf(event.target_id)),
+        tokenPart(event.flag),
+    ]
+        .map((part) => part.slice(0, 32))
+        .filter((part) => part.length > 0)
+        .join('-');
+    const head = `onebot:${tokenPart(config.channel, 40)}:${kind}.${type}:`;
+    const eventKey = head.length + identity.length <= 256
+        ? `${head}${identity.length === 0 ? 'event' : identity}`
+        : `${head}${createHash('sha256').update(identity).digest('hex').slice(0, 16)}`;
+    const scope = groupId === undefined ? 'c2c' : 'group';
+    const sessionKey = groupId === undefined ? `peer:${userId ?? selfId ?? 'unknown'}` : `group:${groupId}`;
+    const summary = summaryOf(event, postType, type, subType, groupId, userId);
+    return {
+        eventKey,
+        kind,
+        event: { postType, type, ...(subType === undefined ? {} : { subType }) },
+        chainId: eventKey,
+        sessionKey,
+        replyTarget: sessionKey,
+        requestId: eventKey,
+        source: { kind: 'onebot', instance: config.channel, peer: groupId ?? userId ?? null, scope },
+        author: {
+            senderId: (postType === 'notice' ? (idOf(event.operator_id) ?? userId) : userId) ?? selfId ?? 'unknown',
+            kind: config.bots.includes(idOf(event.operator_id) ?? userId ?? '') ? 'bot' : 'person',
+            personId: null,
+        },
+        rawText: summary,
+        body: { text: summary, media: [], replyTo: null },
+        transport: {
+            messageId: eventKey,
+            timestamp: observedAt,
+            mentioned: { self: false, others: false, all: false },
+            isReply: false,
+            signature: null,
+        },
+        declared: { nickname: '', avatar: '' },
+        adapter: {},
+        receivedAt: now(),
+    };
+}
+/** Maps one OneBot event onto the inbound message core takes; returns undefined for an event we do not read. */
+export function mapOneBotEvent(event, config, chainOf, warn, now = Date.now) {
+    if (event.post_type === 'message')
+        return mapOneBotMessage(event, config, chainOf, warn, now);
+    return mapOneBotOther(event, config, now);
+}
+class Seen {
+    #seen = new Map();
+    #now;
+    #ttlMs;
+    #limit;
+    constructor(ttlMs, limit, now) {
+        this.#ttlMs = ttlMs;
+        this.#limit = limit;
+        this.#now = now;
+    }
+    /** True when this key was already recorded inside the window; records it otherwise. */
+    claim(key) {
+        const at = this.#now();
+        const seen = this.#seen.get(key);
+        if (seen !== undefined) {
+            this.#seen.delete(key);
+            if (at - seen < this.#ttlMs) {
+                this.#seen.set(key, seen);
+                return true;
+            }
+        }
+        this.#seen.set(key, at);
+        while (this.#seen.size > this.#limit) {
+            const oldest = this.#seen.keys().next();
+            if (oldest.done === true)
+                break;
+            this.#seen.delete(oldest.value);
+        }
+        return false;
+    }
+    get size() {
+        return this.#seen.size;
+    }
+    prune() {
+        const at = this.#now();
+        for (const [key, seen] of this.#seen) {
+            if (at - seen >= this.#ttlMs)
+                this.#seen.delete(key);
+        }
+    }
+}
+/** The OneBot 11 transport: events arrive over reverse HTTP, replies call the implementation's HTTP API. */
+export class OneBotAdapter {
+    kind = 'onebot';
+    guidance = { peer: ONEBOT_PEER_GUIDANCE, group: ONEBOT_GROUP_GUIDANCE };
+    capabilities;
+    #config;
+    #stats;
+    #now;
+    #dedupe;
+    #chainRoot = new Map();
+    #ports;
+    #server;
+    #forward;
+    #reverse;
+    #warn;
+    constructor(config, options = {}) {
+        this.#config = config;
+        this.capabilities = {
+            text: true,
+            image: { in: true, out: true, fromUrl: true, fromHandle: true },
+            file: { in: true, out: true, fromUrl: config.fileFromUrl === true, fromHandle: true },
+            voice: { in: true, out: true, fromUrl: true, fromHandle: true },
+            recall: false,
+            history: {
+                group: config.history?.group === true,
+                private: config.history?.private === true,
+            },
+            mention: true,
+            reply: true,
+            stream: false,
+        };
+        this.#stats = new ChannelStats(options.now);
+        this.#now = options.now ?? Date.now;
+        this.#warn = options.warn;
+        this.#dedupe = new Seen(ONEBOT_DEDUPE_TTL_MS, ONEBOT_DEDUPE_LIMIT, this.#now);
+    }
+    get snapshot() {
+        return this.#stats.snapshot();
+    }
+    checkConfig() {
+        if (this.#config.accessToken !== undefined && this.#config.accessToken.trim().length === 0) {
+            throw new ConfigError('transport.accessToken must name a credential', ['adapters', 'transport', 'accessToken']);
+        }
+    }
+    sessionScope(key) {
+        if (key.startsWith('group:'))
+            return 'group';
+        if (key.startsWith('peer:'))
+            return 'c2c';
+        return undefined;
+    }
+    checkSessionKey(key) {
+        return this.#targetProblem(key, 'session key');
+    }
+    checkTarget(target) {
+        return this.#targetProblem(target, 'target');
+    }
+    describeTargets() {
+        return 'group:<id> or peer:<id>';
+    }
+    status() {
+        const snapshot = this.#stats.snapshot();
+        const listening = snapshot.state === 'listening';
+        const forward = this.#forward;
+        return buildStatus({
+            channel: this.#config.channel,
+            account: this.#config.channel,
+            bot: this.#config.botName,
+            health: forward === undefined ? buildListenerHealth({
+                listenState: listening ? 'listening' : snapshot.state === 'failed' ? 'failed' : 'stopped',
+                boundPort: snapshot.boundPort,
+                lastAuthenticatedAt: this.#reverse?.lastAuthenticatedAt() ?? snapshot.lastAuthenticatedAt,
+                lastFailure: snapshot.lastFailure,
+                queueDepth: snapshot.inFlight,
+            }) : forward.health(),
+            counters: countersOf(snapshot),
+            capabilities: this.capabilities,
+            attributes: { stableMessageId: true },
+            quota: { softLimit: 0, hardLimit: 0 },
+            sampledAt: snapshot.sampledAt,
+            queueDepth: snapshot.inFlight,
+        });
+    }
+    async send(input) {
+        const target = this.#parseTarget(input.target);
+        if (target === undefined) {
+            return { ok: false, code: 'no_url', retryable: false, reason: `this adapter cannot address "${input.target}"` };
+        }
+        const file = (input.media ?? []).find((item) => item.type === 'file');
+        if (file !== undefined) {
+            if (input.body.length > 0) {
+                this.#warn?.('dsbot-channel: dropped the text beside a file: a file send carries its name only');
+            }
+            return this.#sendFile(target, file, input.timeoutMs);
+        }
+        const message = this.#messageOf(input);
+        if (message === undefined) {
+            return { ok: false, code: 'rejected', retryable: false, reason: 'there is nothing this channel can carry' };
+        }
+        const action = target.scope === 'group' ? 'send_group_msg' : 'send_private_msg';
+        const params = target.scope === 'group'
+            ? { group_id: target.id, message }
+            : { user_id: target.id, message };
+        const answered = await this.#call(action, params, input.timeoutMs);
+        if (!answered.ok) {
+            this.#stats.sendFailed(answered.code);
+            return answered;
+        }
+        this.#rememberChain(String(answered.messageId), input.chainId ?? input.eventId);
+        this.#rememberSent(`${target.scope === 'group' ? 'group' : 'peer'}:${target.id}`, String(answered.messageId));
+        return answered;
+    }
+    /** Pages earlier messages through the implementation's history API. */
+    async history(input) {
+        const target = this.#parseTarget(input.target);
+        if (target === undefined) {
+            return { ok: false, code: 'unsupported', reason: `this adapter cannot address "${input.target}"` };
+        }
+        const segment = target.scope === 'group' ? 'group' : 'private';
+        if (this.capabilities.history[segment] !== true) {
+            return { ok: false, code: 'unsupported', reason: `capabilities.history.${segment} is false` };
+        }
+        const action = target.scope === 'group' ? 'get_group_msg_history' : 'get_friend_msg_history';
+        const params = {
+            ...(target.scope === 'group' ? { group_id: target.id } : { user_id: target.id }),
+            count: input.limit,
+            ...(input.before === undefined ? {} : { message_seq: input.before }),
+        };
+        const answered = await this.#historyCall(action, params);
+        if (!answered.ok)
+            return answered;
+        const raw = Array.isArray(answered.data.messages) ? answered.data.messages : [];
+        const records = [];
+        for (const entry of raw) {
+            const record = this.#historyRecord(entry);
+            if (record !== undefined)
+                records.push(record);
+        }
+        // Oldest first, so a reader follows the conversation the way it happened.
+        records.sort((left, right) => left.timestamp - right.timestamp);
+        // `next` is the cursor to pass back as `before` for earlier messages: the oldest record on
+        // this page, not an offset. A page without `next` means there is nothing older.
+        const next = records.length > 0 && records.length >= input.limit ? records[0].cursor : undefined;
+        return { ok: true, records, ...(next === undefined ? {} : { next }) };
+    }
+    #historyRecord(entry) {
+        if (entry === null || typeof entry !== 'object')
+            return undefined;
+        const one = entry;
+        const messageId = idOf(one.message_id);
+        if (messageId === undefined)
+            return undefined;
+        const sender = (one.sender === null || typeof one.sender !== 'object' ? {} : one.sender);
+        const card = typeof sender.card === 'string' && sender.card.length > 0 ? sender.card : undefined;
+        const nickname = card ?? (typeof sender.nickname === 'string' && sender.nickname.length > 0 ? sender.nickname : undefined);
+        const cursor = idOf(one.message_seq) ?? idOf(one.real_seq) ?? messageId;
+        const seconds = typeof one.time === 'number' && Number.isFinite(one.time) ? one.time : 0;
+        return {
+            messageId,
+            cursor,
+            timestamp: seconds * 1000,
+            senderId: idOf(sender.user_id) ?? '',
+            text: segmentText(one.message),
+            ...(nickname === undefined ? {} : { nickname }),
+        };
+    }
+    async #historyCall(action, params) {
+        const ports = this.#ports;
+        if (ports === undefined) {
+            return { ok: false, code: 'unreachable', reason: 'the onebot adapter is not started' };
+        }
+        if (this.#config.protocol !== 'http') {
+            const socket = this.#socketLink();
+            if (socket === undefined) {
+                return { ok: false, code: 'unreachable', reason: 'the socket is not open' };
+            }
+            const answer = await socket.request(action, params, undefined);
+            if (!answer.ok) {
+                if (/^消息.*不存在$/.test(answer.reason))
+                    return { ok: true, data: {} };
+                if (/^记录.*不存在$/.test(answer.reason))
+                    return { ok: false, code: 'rejected', reason: answer.reason };
+                return { ok: false, code: answer.code, reason: answer.reason };
+            }
+            const data = answer.frame.data;
+            return { ok: true, data: data !== null && typeof data === 'object' ? data : {} };
+        }
+        const api = this.#config.api;
+        if (api === undefined) {
+            return { ok: false, code: 'unsupported', reason: 'this protocol has no http action api' };
+        }
+        const token = this.#config.accessToken === undefined ? undefined : await ports.resolveSecret(this.#config.accessToken);
+        if (this.#config.accessToken !== undefined && token === undefined) {
+            return { ok: false, code: 'credential', reason: 'the onebot access token did not resolve' };
+        }
+        let response;
+        try {
+            response = await fetch(`${api.url}/${action}`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(token === undefined ? {} : { authorization: `Bearer ${token}` }),
+                },
+                body: JSON.stringify(params),
+                signal: AbortSignal.timeout(this.#config.sendTimeoutMs),
+            });
+        }
+        catch (error) {
+            const timeout = error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
+            return {
+                ok: false,
+                code: timeout ? 'timeout' : 'unreachable',
+                reason: timeout ? 'the onebot api did not answer in time' : `the onebot api is unreachable: ${String(error)}`,
+            };
+        }
+        let parsed;
+        try {
+            parsed = (await response.json());
+        }
+        catch {
+            if (response.status === 404) {
+                return { ok: false, code: 'unsupported', reason: 'the implementation has no such history action' };
+            }
+            return { ok: false, code: 'rejected', reason: `the api answered ${response.status} without json` };
+        }
+        const message = this.#oneLine(parsed.message ?? '');
+        if (response.status === 401 || response.status === 403 || parsed.retcode === 1403) {
+            return { ok: false, code: 'unauthorized', reason: message === '' ? 'unauthorized' : message };
+        }
+        if (/^消息.*不存在$/.test(message))
+            return { ok: true, data: {} };
+        if (/^记录.*不存在$/.test(message))
+            return { ok: false, code: 'rejected', reason: message };
+        if (response.status === 404) {
+            return { ok: false, code: 'unsupported', reason: message === '' ? 'the implementation has no such history action' : message };
+        }
+        if (!response.ok || parsed.status === 'failed' || (parsed.retcode !== undefined && parsed.retcode !== 0)) {
+            return {
+                ok: false,
+                code: response.status >= 500 ? 'unreachable' : 'rejected',
+                reason: message === '' ? `the api answered ${response.status}` : message,
+            };
+        }
+        if (parsed.data === null || typeof parsed.data !== 'object')
+            return { ok: true, data: {} };
+        return { ok: true, data: parsed.data };
+    }
+    /** Uploads one file; the implementation takes a url only when the profile said it does. */
+    async #sendFile(target, item, timeoutMs) {
+        const capability = this.capabilities.file;
+        if (capability.out !== true) {
+            return { ok: false, code: 'unsupported', retryable: false, reason: 'this channel cannot send files' };
+        }
+        if (item.url !== null && capability.fromUrl !== true) {
+            return {
+                ok: false,
+                code: 'unsupported',
+                retryable: false,
+                reason: 'this channel cannot take a file from a url; transport.fileFromUrl is false',
+            };
+        }
+        const file = item.url ?? item.handle;
+        if (file === null) {
+            return { ok: false, code: 'no_url', retryable: false, reason: 'the file names neither a url nor a handle' };
+        }
+        if (item.url === null) {
+            if (capability.fromHandle !== true) {
+                return { ok: false, code: 'unsupported', retryable: false, reason: 'this channel cannot take a file from a handle' };
+            }
+            const owner = item.owner;
+            if (owner === undefined || owner.kind !== this.kind || owner.instance !== this.#config.channel) {
+                this.#warn?.('dsbot-channel: dropped a file whose handle belongs to another instance');
+                return {
+                    ok: false,
+                    code: 'rejected',
+                    retryable: false,
+                    reason: 'This file handle was issued by another instance; send it back on the instance that received it.',
+                };
+            }
+        }
+        const name = item.name;
+        if (name === undefined || name.trim().length === 0) {
+            return { ok: false, code: 'rejected', retryable: false, reason: 'a file needs a name' };
+        }
+        const action = target.scope === 'group' ? 'upload_group_file' : 'upload_private_file';
+        const params = target.scope === 'group' ? { group_id: target.id, file, name } : { user_id: target.id, file, name };
+        const sent = await this.#uploadCall(action, params, timeoutMs);
+        if (sent.ok)
+            this.#rememberSent(`${target.scope === 'group' ? 'group' : 'peer'}:${target.id}`, sent.messageId);
+        return sent;
+    }
+    async #uploadCall(action, params, timeoutMs) {
+        const ports = this.#ports;
+        if (ports === undefined) {
+            return { ok: false, code: 'unreachable', retryable: true, reason: 'the onebot adapter is not started' };
+        }
+        if (this.#config.protocol !== 'http') {
+            const socket = this.#socketLink();
+            if (socket === undefined) {
+                return { ok: false, code: 'unreachable', retryable: true, reason: 'the socket is not open' };
+            }
+            const answer = await socket.request(action, params, timeoutMs);
+            if (!answer.ok) {
+                return { ok: false, code: answer.code, retryable: answer.code === 'unreachable', reason: answer.reason };
+            }
+            const data = answer.frame.data;
+            const payload = data !== null && typeof data === 'object' ? data : {};
+            const given = idOf(payload.file_id) ?? idOf(payload.message_id);
+            return { ok: true, messageId: given ?? `local:${randomUUID()}`, duplicate: false };
+        }
+        const api = this.#config.api;
+        if (api === undefined) {
+            return { ok: false, code: 'unsupported', retryable: false, reason: 'this protocol has no http action api' };
+        }
+        const token = this.#config.accessToken === undefined ? undefined : await ports.resolveSecret(this.#config.accessToken);
+        if (this.#config.accessToken !== undefined && token === undefined) {
+            return { ok: false, code: 'credential', retryable: false, reason: 'the onebot access token did not resolve' };
+        }
+        let response;
+        try {
+            response = await fetch(`${api.url}/${action}`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(token === undefined ? {} : { authorization: `Bearer ${token}` }),
+                },
+                body: JSON.stringify(params),
+                signal: AbortSignal.timeout(timeoutMs ?? this.#config.sendTimeoutMs),
+            });
+        }
+        catch (error) {
+            const timeout = error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
+            return {
+                ok: false,
+                code: timeout ? 'timeout' : 'unreachable',
+                retryable: !timeout,
+                reason: timeout ? 'the onebot api did not answer in time' : `the onebot api is unreachable: ${String(error)}`,
+            };
+        }
+        let parsed;
+        try {
+            parsed = (await response.json());
+        }
+        catch {
+            if (response.status === 404) {
+                return { ok: false, code: 'unsupported', retryable: false, reason: 'the implementation has no upload action' };
+            }
+            return {
+                ok: false,
+                code: 'rejected',
+                retryable: response.status >= 500,
+                reason: `the api answered ${response.status} without json`,
+            };
+        }
+        const message = this.#oneLine(parsed.message ?? '');
+        if (response.status === 401 || response.status === 403) {
+            return { ok: false, code: 'unauthorized', retryable: false, reason: message === '' ? 'unauthorized' : message };
+        }
+        if (response.status === 404) {
+            return {
+                ok: false,
+                code: 'unsupported',
+                retryable: false,
+                reason: message === '' ? 'the implementation has no upload action' : message,
+            };
+        }
+        if (!response.ok || parsed.status !== 'ok') {
+            return {
+                ok: false,
+                code: response.status >= 500 ? 'unreachable' : 'rejected',
+                retryable: response.status >= 500,
+                reason: message === '' ? `the api answered ${response.status}` : message,
+            };
+        }
+        const data = (parsed.data ?? {});
+        const given = idOf(data.file_id) ?? idOf(data.message_id);
+        return { ok: true, messageId: given ?? `local:${randomUUID()}`, duplicate: false };
+    }
+    /** The text alone when there is no media, otherwise the segments this instance may carry. */
+    #messageOf(input) {
+        const segments = [];
+        if (input.body.length > 0)
+            segments.push({ type: 'text', data: { text: input.body } });
+        for (const item of input.media ?? []) {
+            const segment = item.type === 'image' ? 'image' : item.type === 'voice' ? 'record' : undefined;
+            if (segment === undefined) {
+                this.#warn?.(`dsbot-channel: dropped a ${item.type} from the send: this version sends images and voice`);
+                continue;
+            }
+            const capability = item.type === 'image' ? this.capabilities.image : this.capabilities.voice;
+            if (capability.out !== true) {
+                this.#warn?.(`dsbot-channel: dropped a ${item.type} from the send: capabilities.${item.type}.out is false`);
+                continue;
+            }
+            if (item.url === null && item.handle === null) {
+                this.#warn?.('dsbot-channel: dropped a media item from the send: it names neither a url nor a handle');
+                continue;
+            }
+            if (item.url === null && (typeof item.handle !== 'string' || handleProblem(item.handle) !== undefined)) {
+                this.#warn?.('dsbot-channel: dropped a media item from the send: its handle is not one printable token');
+                continue;
+            }
+            const source = item.url !== null ? capability.fromUrl : capability.fromHandle;
+            if (source !== true) {
+                this.#warn?.(`dsbot-channel: dropped a ${item.type} from the send: this channel cannot take it from that source`);
+                continue;
+            }
+            if (item.url === null) {
+                const owner = item.owner;
+                if (owner === undefined || owner.kind !== this.kind || owner.instance !== this.#config.channel) {
+                    this.#warn?.(`dsbot-channel: dropped a ${item.type} whose handle belongs to another instance`);
+                    continue;
+                }
+            }
+            segments.push({ type: segment, data: { file: (item.url ?? item.handle) } });
+        }
+        if (segments.length === 0)
+            return undefined;
+        if (segments.length === 1 && segments[0].type === 'text')
+            return input.body;
+        return segments;
+    }
+    /** The socket a websocket protocol speaks through, whichever direction it dials. */
+    #socketLink() {
+        if (this.#config.protocol === 'ws-forward')
+            return this.#forward;
+        if (this.#config.protocol === 'ws-reverse')
+            return this.#reverse;
+        return undefined;
+    }
+    async start(ports) {
+        if (this.#config.protocol === 'ws-forward')
+            return this.#startForward(ports);
+        if (this.#config.protocol === 'ws-reverse')
+            return this.#startReverse(ports);
+        const listen = this.#config.listen;
+        if (this.#config.protocol !== 'http' || listen === undefined) {
+            throw new ConfigError(`transport.protocol "${this.#config.protocol}" is not wired yet; this build answers over http`, ['adapters', 'transport', 'protocol']);
+        }
+        this.#ports = ports;
+        if (this.#config.accessToken !== undefined) {
+            const token = await ports.resolveSecret(this.#config.accessToken);
+            if (token === undefined) {
+                throw new ConfigError('transport.accessToken names a credential that did not resolve', [
+                    'adapters',
+                    'transport',
+                    'accessToken',
+                ]);
+            }
+        }
+        const server = createServer((request, response) => {
+            void this.#handle(request, response);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(listen.port, listen.host, () => {
+                server.off('error', reject);
+                resolve();
+            });
+        }).catch((error) => {
+            this.#stats.failed(error instanceof Error ? error.message : String(error));
+            throw error;
+        });
+        this.#server = server;
+        this.#stats.listening(server.address().port);
+        return {
+            stop: async () => {
+                await new Promise((resolve) => server.close(() => resolve()));
+                this.#stats.closed();
+            },
+            address: () => ({ port: server.address().port }),
+        };
+    }
+    /** Stops the listener without going through the handle, for tests and for a failed mount. */
+    async stop() {
+        const server = this.#server;
+        this.#server = undefined;
+        if (server === undefined)
+            return;
+        await new Promise((resolve) => server.close(() => resolve()));
+        this.#stats.closed();
+    }
+    #recentSent = new Map();
+    #rememberSent(session, messageId) {
+        const list = this.#recentSent.get(session) ?? [];
+        list.push(messageId);
+        while (list.length > 20)
+            list.shift();
+        this.#recentSent.set(session, list);
+    }
+    #rememberChain(messageId, chainId) {
+        this.#chainRoot.set(messageId, chainId);
+        while (this.#chainRoot.size > ONEBOT_CHAIN_LIMIT) {
+            const oldest = this.#chainRoot.keys().next();
+            if (oldest.done === true)
+                break;
+            this.#chainRoot.delete(oldest.value);
+        }
+    }
+    #targetProblem(value, label) {
+        if (typeof value !== 'string' || value.length === 0)
+            return `${label} must be a non-empty string`;
+        if (this.#parseTarget(value) === undefined)
+            return `${label} must look like group:<id> or peer:<id>: "${value}"`;
+        return undefined;
+    }
+    #parseTarget(value) {
+        const match = /^(group|peer):([0-9A-Za-z_-]+)$/.exec(value);
+        if (match === null)
+            return undefined;
+        return { scope: match[1] === 'group' ? 'group' : 'c2c', id: match[2] };
+    }
+    async #call(action, params, timeoutMs) {
+        const ports = this.#ports;
+        if (ports === undefined)
+            return { ok: false, code: 'unreachable', retryable: true, reason: 'the onebot adapter is not started' };
+        if (this.#config.protocol !== 'http') {
+            const socket = this.#socketLink();
+            if (socket === undefined)
+                return { ok: false, code: 'unreachable', retryable: true, reason: 'the socket is not open' };
+            const answer = await socket.request(action, params, timeoutMs);
+            if (!answer.ok) {
+                return { ok: false, code: answer.code, retryable: answer.code === 'unreachable', reason: answer.reason };
+            }
+            const data = answer.frame.data;
+            const messageId = data !== null && typeof data === 'object' ? idOf(data.message_id) : undefined;
+            if (messageId === undefined) {
+                return { ok: false, code: 'rejected', retryable: false, reason: 'the api answered without a message id' };
+            }
+            return { ok: true, messageId, duplicate: false };
+        }
+        const api = this.#config.api;
+        if (api === undefined) {
+            return { ok: false, code: 'unsupported', retryable: false, reason: 'this protocol has no http action api' };
+        }
+        const token = this.#config.accessToken === undefined ? undefined : await ports.resolveSecret(this.#config.accessToken);
+        if (this.#config.accessToken !== undefined && token === undefined) {
+            return { ok: false, code: 'credential', retryable: false, reason: 'the onebot access token did not resolve' };
+        }
+        let response;
+        try {
+            response = await fetch(`${api.url}/${action}`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(token === undefined ? {} : { authorization: `Bearer ${token}` }),
+                },
+                body: JSON.stringify(params),
+                signal: AbortSignal.timeout(timeoutMs ?? this.#config.sendTimeoutMs),
+            });
+        }
+        catch (error) {
+            const timeout = error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
+            return {
+                ok: false,
+                code: timeout ? 'timeout' : 'unreachable',
+                retryable: !timeout,
+                reason: timeout ? 'the onebot api did not answer in time' : `the onebot api is unreachable: ${String(error)}`,
+            };
+        }
+        let parsed;
+        try {
+            parsed = (await response.json());
+        }
+        catch {
+            return { ok: false, code: 'rejected', retryable: response.status >= 500, reason: `the api answered ${response.status} without json` };
+        }
+        if (response.status === 401 || response.status === 403 || parsed.retcode === 1403) {
+            return { ok: false, code: 'unauthorized', retryable: false, reason: this.#oneLine(parsed.message ?? 'unauthorized') };
+        }
+        if (!response.ok || (parsed.retcode !== undefined && parsed.retcode !== 0)) {
+            return {
+                ok: false,
+                code: response.status >= 500 ? 'unreachable' : 'rejected',
+                retryable: response.status >= 500,
+                reason: this.#oneLine(parsed.message ?? `the api answered ${response.status}`),
+            };
+        }
+        const messageId = idOf(parsed.data?.message_id);
+        if (messageId === undefined)
+            return { ok: false, code: 'rejected', retryable: false, reason: 'the api answered without a message id' };
+        return { ok: true, messageId, duplicate: false };
+    }
+    #oneLine(value) {
+        return String(value).replace(/\s+/g, ' ').trim().slice(0, 200);
+    }
+    async #authorized(request) {
+        if (this.#config.accessToken === undefined)
+            return true;
+        const expected = await this.#ports?.resolveSecret(this.#config.accessToken);
+        if (expected === undefined || expected.length === 0)
+            return false;
+        const header = request.headers.authorization;
+        if (typeof header !== 'string')
+            return false;
+        const match = /^(?:Bearer|Token)\s+(.+)$/i.exec(header.trim());
+        if (match === null)
+            return false;
+        const offered = Buffer.from(match[1], 'utf8');
+        const secret = Buffer.from(expected, 'utf8');
+        return offered.length === secret.length && timingSafeEqual(offered, secret);
+    }
+    async #handle(request, response) {
+        if (this.#config.status !== false &&
+            answerStatus(request, response, {
+                route: ONEBOT_STATUS_ROUTE,
+                report: () => this.status(),
+                onRefused: () => this.#stats.unknownPath(),
+            })) {
+            return;
+        }
+        const url = request.url ?? '/';
+        if (request.method !== 'POST' || url !== this.#config.listen?.path) {
+            this.#stats.unknownPath();
+            response.writeHead(404, { 'content-type': 'application/json' });
+            response.end('{"status":"failed","retcode":1404,"message":"not found"}');
+            return;
+        }
+        if (!(await this.#authorized(request))) {
+            this.#stats.authFailure();
+            this.#stats.rejected('unauthorized');
+            response.writeHead(401, { 'content-type': 'application/json' });
+            response.end('{"status":"failed","retcode":1403,"message":"unauthorized"}');
+            return;
+        }
+        const raw = await this.#readBody(request);
+        if (raw === undefined) {
+            response.writeHead(413, { 'content-type': 'application/json' });
+            response.end('{"status":"failed","retcode":1404,"message":"body too large"}');
+            return;
+        }
+        let event;
+        try {
+            event = JSON.parse(raw);
+        }
+        catch {
+            response.writeHead(400, { 'content-type': 'application/json' });
+            response.end('{"status":"failed","retcode":1400,"message":"body must be json"}');
+            return;
+        }
+        // OneBot implementations resend a non-2xx answer, so every event is accepted or dropped here, not refused.
+        response.writeHead(204);
+        response.end();
+        await this.#acceptEvent(event);
+    }
+    /** Turns one OneBot event into a message and hands it to core, whatever carried it. */
+    async #acceptEvent(event) {
+        const message = mapOneBotEvent(event, this.#config, (messageId) => this.#chainRoot.get(messageId), this.#warn, this.#now);
+        if (message !== undefined &&
+            this.#dedupe.claim(`${message.source.scope}:${message.replyTarget}:${message.requestId}`)) {
+            this.#warn?.(`dsbot-channel: kept a repeated onebot event ${message.requestId} from ${message.replyTarget} out of a turn`);
+            return;
+        }
+        if (message !== undefined && (message.kind ?? 'message') === 'message' && message.body.replyTo !== null) {
+            const recent = this.#recentSent.get(message.sessionKey);
+            if (recent !== undefined && recent.includes(message.body.replyTo))
+                message.replyToMe = true;
+        }
+        const code = oneBotEventClass(event);
+        if (code !== undefined)
+            this.#stats.event(code);
+        if (message === undefined)
+            return;
+        this.#rememberChain(message.requestId, message.chainId);
+        const ports = this.#ports;
+        if (ports === undefined)
+            return;
+        try {
+            const verdict = await ports.onMessage(message);
+            if (!verdict.ok) {
+                this.#warn?.(`dsbot-channel: kept ${message.requestId} from ${message.replyTarget} out of a turn: ${verdict.code} ${verdict.reason}`);
+            }
+        }
+        catch (error) {
+            this.#warn?.(`dsbot-channel: handing off ${message.requestId} failed: ${String(error)}`);
+        }
+    }
+    /** Hosts a socket the implementation dials, and answers its actions on that socket. */
+    async #startReverse(ports) {
+        const listen = this.#config.listen;
+        if (listen === undefined) {
+            throw new ConfigError('transport.listen is required for ws-reverse', ['adapters', 'transport', 'listen']);
+        }
+        const token = this.#config.accessToken === undefined ? undefined : await ports.resolveSecret(this.#config.accessToken);
+        if (this.#config.accessToken !== undefined && token === undefined) {
+            throw new ConfigError('transport.accessToken names a credential that did not resolve', [
+                'adapters',
+                'transport',
+                'accessToken',
+            ]);
+        }
+        this.#ports = ports;
+        const link = new ReverseLink({
+            path: listen.path,
+            token,
+            ...(this.#config.selfId === undefined ? {} : { selfId: this.#config.selfId }),
+            maxFrameBytes: ONEBOT_MAX_BODY_BYTES,
+            timeoutMs: this.#config.sendTimeoutMs,
+            ...(this.#config.heartbeat === undefined ? {} : { heartbeat: this.#config.heartbeat }),
+            onEvent: (frame) => {
+                void this.#acceptEvent(frame);
+            },
+            onMismatch: () => this.#stats.protocolMismatch(),
+            onAuthFailure: () => this.#stats.authFailure(),
+            onUnknownPath: () => this.#stats.unknownPath(),
+            warn: (message) => this.#warn?.(message),
+        });
+        this.#reverse = link;
+        const server = createServer((request, response) => {
+            if (this.#config.status !== false &&
+                answerStatus(request, response, {
+                    route: ONEBOT_STATUS_ROUTE,
+                    report: () => this.status(),
+                    onRefused: () => this.#stats.unknownPath(),
+                })) {
+                return;
+            }
+            this.#stats.unknownPath();
+            response.writeHead(404, { 'content-type': 'application/json' });
+            response.end('{"status":"failed","retcode":1404,"message":"not found"}');
+        });
+        link.attach(server);
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(listen.port, listen.host, () => {
+                server.off('error', reject);
+                resolve();
+            });
+        }).catch((error) => {
+            this.#stats.failed(error instanceof Error ? error.message : String(error));
+            throw error;
+        });
+        this.#server = server;
+        this.#stats.listening(server.address().port);
+        return {
+            stop: async () => {
+                link.close();
+                this.#reverse = undefined;
+                await new Promise((resolve) => server.close(() => resolve()));
+                this.#stats.closed();
+            },
+            address: () => ({ port: server.address().port }),
+        };
+    }
+    /** Dials the implementation's socket and hands what arrives to the same event path. */
+    async #startForward(ports) {
+        const api = this.#config.api;
+        if (api === undefined) {
+            throw new ConfigError('transport.api is required for ws-forward', ['adapters', 'transport', 'api']);
+        }
+        const token = this.#config.accessToken === undefined ? undefined : await ports.resolveSecret(this.#config.accessToken);
+        if (this.#config.accessToken !== undefined && token === undefined) {
+            throw new ConfigError('transport.accessToken names a credential that did not resolve', [
+                'adapters',
+                'transport',
+                'accessToken',
+            ]);
+        }
+        this.#ports = ports;
+        const link = new ForwardLink({
+            apiUrl: api.url,
+            ...(this.#config.event === undefined ? {} : { eventUrl: this.#config.event.url }),
+            token,
+            reconnect: this.#config.reconnect ?? { initialMs: 500, maxMs: 30_000, factor: 2 },
+            ...(this.#config.heartbeat === undefined ? {} : { heartbeat: this.#config.heartbeat }),
+            timeoutMs: this.#config.sendTimeoutMs,
+            maxFrameBytes: ONEBOT_MAX_BODY_BYTES,
+            onEvent: (frame) => {
+                void this.#acceptEvent(frame);
+            },
+            onMismatch: () => this.#stats.protocolMismatch(),
+            warn: (message) => this.#warn?.(message),
+        });
+        this.#forward = link;
+        link.start();
+        return {
+            stop: async () => {
+                link.close();
+                this.#forward = undefined;
+            },
+        };
+    }
+    #readBody(request) {
+        return new Promise((resolve) => {
+            const chunks = [];
+            let size = 0;
+            let settled = false;
+            const settle = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            request.on('data', (chunk) => {
+                size += chunk.length;
+                if (size > ONEBOT_MAX_BODY_BYTES) {
+                    chunks.length = 0;
+                    settle(undefined);
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            request.on('end', () => settle(Buffer.concat(chunks).toString('utf8')));
+            request.on('error', () => settle(undefined));
+        });
+    }
+}