DrSmoothl
c16064d7e3
The package previously named "bridge" houses the protocol-byte layer (OIDB cmds, msg-push decoders, highway uploaders, element-builder, event bus). The name "bridge" suggested transport/lifecycle, which it isn't — that role lives in core/hook and core/bridge/manager. Rename to match what's actually inside. This is a pure rename: zero logic changes, all 73 import sites updated mechanically and TS-verified. core/onebot dependencies key updated. ESLint override path adjusted for the moved oidb-services directory. Rename detection threshold: git log --find-renames=20% recommended when following history across this commit — content-replacement (@snowluma/bridge → @snowluma/protocol) dropped per-file similarity below git's default 50% on import-heavy files.
484 lines
17 KiB
TypeScript
484 lines
17 KiB
TypeScript
import fs from 'fs';
|
|
import os from 'os';
|
|
import path from 'path';
|
|
import { describe, it, expect, vi } from 'vitest';
|
|
import { protobuf_decode, protobuf_encode } from '@snowluma/proton';
|
|
import { parseMessage } from '../src/message-parser';
|
|
import { buildSendElems } from '@snowluma/protocol/element-builder';
|
|
import type { MentionExtraSend } from '@snowluma/proto-defs/action';
|
|
import type { OidbBase } from '@snowluma/proto-defs/oidb';
|
|
import type { NTV2UploadRichMediaResp } from '@snowluma/proto-defs/highway';
|
|
|
|
describe('parseMessage', () => {
|
|
describe('plain text', () => {
|
|
it('parses simple text', async () => {
|
|
const result = await parseMessage('hello world', false);
|
|
expect(result).toEqual([{ type: 'text', text: 'hello world' }]);
|
|
});
|
|
|
|
it('returns empty for empty string', async () => {
|
|
const result = await parseMessage('', false);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('autoEscape treats CQ codes as text', async () => {
|
|
const result = await parseMessage('[CQ:face,id=123]', true);
|
|
expect(result).toEqual([{ type: 'text', text: '[CQ:face,id=123]' }]);
|
|
});
|
|
});
|
|
|
|
describe('CQ code parsing', () => {
|
|
it('parses face CQ code', async () => {
|
|
const result = await parseMessage('[CQ:face,id=123]', false);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('face');
|
|
expect(result[0].faceId).toBe(123);
|
|
});
|
|
|
|
it('parses at CQ code', async () => {
|
|
const result = await parseMessage('[CQ:at,qq=12345]', false);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('at');
|
|
expect(result[0].targetUin).toBe(12345);
|
|
});
|
|
|
|
it('parses at all', async () => {
|
|
const result = await parseMessage('[CQ:at,qq=all]', false);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('at');
|
|
expect(result[0].targetUin).toBe(0);
|
|
});
|
|
|
|
it('parses mixed text and CQ codes', async () => {
|
|
const result = await parseMessage('Hello [CQ:face,id=1] World', false);
|
|
expect(result).toHaveLength(3);
|
|
expect(result[0]).toEqual({ type: 'text', text: 'Hello ' });
|
|
expect(result[1].type).toBe('face');
|
|
expect(result[2]).toEqual({ type: 'text', text: ' World' });
|
|
});
|
|
|
|
it('unescapes CQ special chars', async () => {
|
|
const result = await parseMessage('a&b[c]d', false);
|
|
expect(result).toEqual([{ type: 'text', text: 'a&b[c]d' }]);
|
|
});
|
|
});
|
|
|
|
describe('JSON segment array', () => {
|
|
it('parses text segment', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'text', data: { text: 'hello' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'text', text: 'hello' }]);
|
|
});
|
|
|
|
it('parses face segment', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'face', data: { id: 123 } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('face');
|
|
expect(result[0].faceId).toBe(123);
|
|
});
|
|
|
|
it('parses image segment', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'image', data: { file: 'https://example.com/img.png' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('image');
|
|
expect(result[0].url).toBe('https://example.com/img.png');
|
|
});
|
|
|
|
it('parses record segment from data.file', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'record', data: { file: 'file:///tmp/voice.amr' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'record', url: 'file:///tmp/voice.amr' }]);
|
|
});
|
|
|
|
it('parses video segment from data.path and preserves thumb', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'video', data: { path: '/tmp/clip.mp4', thumb: '/tmp/clip.png' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'video', url: '/tmp/clip.mp4', thumbUrl: '/tmp/clip.png' }]);
|
|
});
|
|
|
|
it('parses AstrBot-style Video segment with top-level media', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'Video', media: 'file:////AstrBot/data/cache/BV-test.mp4' }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'video', url: 'file:////AstrBot/data/cache/BV-test.mp4', thumbUrl: undefined }]);
|
|
});
|
|
|
|
it('drops video segment with empty source', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'video', data: {} }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('parses record segment from data.path (NapCat parity)', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'record', data: { path: 'C:\\voices\\hi.silk' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'record', url: 'C:\\voices\\hi.silk' }]);
|
|
});
|
|
|
|
it('drops record segment with empty source', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'record', data: {} }] as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('parses at segment', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'at', data: { qq: 12345 } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('at');
|
|
expect(result[0].targetUin).toBe(12345);
|
|
});
|
|
|
|
it('uses at segment name for display text and preserves uid', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'at', data: { qq: '123456', name: 'User', uid: 'u_test_uid' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0]).toMatchObject({
|
|
type: 'at',
|
|
targetUin: 123456,
|
|
uid: 'u_test_uid',
|
|
text: '@User ',
|
|
});
|
|
});
|
|
|
|
it('resolves missing at uid through parse options', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'at', data: { qq: '123456', name: 'User' } }] as any,
|
|
false,
|
|
{ resolveMentionUid: async (targetUin) => targetUin === 123456 ? 'u_resolved_uid' : null },
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0]).toMatchObject({
|
|
type: 'at',
|
|
targetUin: 123456,
|
|
uid: 'u_resolved_uid',
|
|
text: '@User ',
|
|
});
|
|
});
|
|
|
|
it('encodes mention extra with resolved uid for QQ notification', async () => {
|
|
const elements = await parseMessage(
|
|
[{ type: 'at', data: { qq: '123456', name: 'User' } }] as any,
|
|
false,
|
|
{ resolveMentionUid: () => 'u_resolved_uid' },
|
|
);
|
|
const protoElems = await buildSendElems(elements);
|
|
const reserve = protoElems[0].text?.pbReserve;
|
|
expect(reserve).toBeInstanceOf(Uint8Array);
|
|
const extra = protobuf_decode<MentionExtraSend>(reserve as Uint8Array);
|
|
expect(extra).toMatchObject({
|
|
type: 2,
|
|
uin: 123456,
|
|
uid: 'u_resolved_uid',
|
|
});
|
|
expect(protoElems[0].text?.str).toBe('@User ');
|
|
});
|
|
|
|
it('skips record send when SendContext is absent (graceful no-bridge path)', async () => {
|
|
// Without a SendContext, buildSendElems can't run highway upload —
|
|
// it should warn and drop the element instead of throwing into the
|
|
// ffmpegAddon (which would explode for callers that don't actually
|
|
// need to send).
|
|
const elements = await parseMessage(
|
|
[
|
|
{ type: 'text', data: { text: 'hi ' } },
|
|
{ type: 'record', data: { file: '/tmp/x.silk' } },
|
|
] as any,
|
|
false,
|
|
);
|
|
const protoElems = await buildSendElems(elements);
|
|
// Only the leading text should make it through.
|
|
expect(protoElems).toHaveLength(1);
|
|
expect(protoElems[0].text?.str).toBe('hi ');
|
|
});
|
|
|
|
it('skips video send when SendContext is absent (graceful no-bridge path)', async () => {
|
|
const elements = await parseMessage(
|
|
[
|
|
{ type: 'text', data: { text: 'hi ' } },
|
|
{ type: 'video', data: { file: '/tmp/x.mp4' } },
|
|
] as any,
|
|
false,
|
|
);
|
|
const protoElems = await buildSendElems(elements);
|
|
expect(protoElems).toHaveLength(1);
|
|
expect(protoElems[0].text?.str).toBe('hi ');
|
|
});
|
|
|
|
it('builds video commonElem through NTV2 fast-upload response', async () => {
|
|
const videoPath = path.join(os.tmpdir(), `snowluma-video-test-${process.pid}-${Date.now()}.mp4`);
|
|
fs.writeFileSync(videoPath, Buffer.from([0, 1, 2, 3]));
|
|
|
|
const responseData = protobuf_encode<OidbBase<NTV2UploadRichMediaResp>>({
|
|
command: 0x11EA,
|
|
subCommand: 100,
|
|
errorCode: 0,
|
|
body: {
|
|
respHead: { retCode: 0, message: '' },
|
|
upload: {
|
|
uKey: '',
|
|
msgInfo: {
|
|
msgInfoBody: [
|
|
{ index: { fileUuid: 'video-uuid' }, fileExist: true },
|
|
{ index: { fileUuid: 'thumb-uuid' }, fileExist: true },
|
|
],
|
|
extBizInfo: {
|
|
video: { bytesPbReserve: new Uint8Array([0x80, 0x01, 0x00]) },
|
|
},
|
|
},
|
|
subFileInfos: [{ uKey: '' }],
|
|
},
|
|
},
|
|
errorMsg: '',
|
|
reserved: 1,
|
|
});
|
|
|
|
const bridge = {
|
|
identity: { uin: '10000' },
|
|
sendRawPacket: vi.fn(async () => ({
|
|
success: true,
|
|
gotResponse: true,
|
|
errorCode: 0,
|
|
errorMessage: '',
|
|
responseData,
|
|
})),
|
|
} as any;
|
|
|
|
try {
|
|
const protoElems = await buildSendElems([{
|
|
type: 'video',
|
|
url: videoPath,
|
|
thumbUrl: 'base64://iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=',
|
|
}], { bridge, groupId: 123456 });
|
|
|
|
expect(bridge.sendRawPacket).toHaveBeenCalledTimes(1);
|
|
expect(bridge.sendRawPacket).toHaveBeenCalledWith('OidbSvcTrpcTcp.0x11ea_100', expect.any(Uint8Array));
|
|
expect(protoElems).toHaveLength(1);
|
|
expect(protoElems[0].commonElem?.serviceType).toBe(48);
|
|
expect(protoElems[0].commonElem?.businessType).toBe(21);
|
|
expect(protoElems[0].commonElem?.pbElem).toBeInstanceOf(Uint8Array);
|
|
} finally {
|
|
try { fs.unlinkSync(videoPath); } catch { /* ignore */ }
|
|
}
|
|
});
|
|
|
|
it('parses multiple segments', async () => {
|
|
const result = await parseMessage(
|
|
[
|
|
{ type: 'text', data: { text: 'hi ' } },
|
|
{ type: 'at', data: { qq: 999 } },
|
|
{ type: 'text', data: { text: ' there' } },
|
|
] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(3);
|
|
expect(result[0].type).toBe('text');
|
|
expect(result[1].type).toBe('at');
|
|
expect(result[2].type).toBe('text');
|
|
});
|
|
|
|
it('skips unknown segment types', async () => {
|
|
const result = await parseMessage(
|
|
[
|
|
{ type: 'text', data: { text: 'ok' } },
|
|
{ type: 'unknown_type_xyz', data: {} },
|
|
] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('text');
|
|
});
|
|
});
|
|
|
|
describe('special segments', () => {
|
|
it('parses json segment', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'json', data: { data: '{"app":"test"}' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('json');
|
|
expect(result[0].text).toBe('{"app":"test"}');
|
|
});
|
|
|
|
it('parses reply segment with resolveReplySequence', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'reply', data: { id: 42 } }] as any,
|
|
false,
|
|
{ resolveReplySequence: (id) => id === 42 ? 100 : null },
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('reply');
|
|
expect(result[0].replySeq).toBe(100);
|
|
});
|
|
|
|
it('parses share as json card', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'share', data: { url: 'https://example.com', title: 'Test' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('json');
|
|
expect(result[0].text).toBeDefined();
|
|
const parsed = JSON.parse(result[0].text!);
|
|
expect(parsed.app).toBe('com.tencent.structmsg');
|
|
expect(parsed.meta.news.title).toBe('Test');
|
|
});
|
|
|
|
it('parses rps as face', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'rps', data: {} }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('face');
|
|
expect(result[0].faceId).toBe(359);
|
|
});
|
|
|
|
it('parses dice as face', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'dice', data: {} }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('face');
|
|
expect(result[0].faceId).toBe(358);
|
|
});
|
|
|
|
it('parses shake as poke', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'shake', data: {} }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('poke');
|
|
});
|
|
|
|
it('ignores anonymous segment', async () => {
|
|
const result = await parseMessage(
|
|
[
|
|
{ type: 'anonymous', data: {} },
|
|
{ type: 'text', data: { text: 'hi' } },
|
|
] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('text');
|
|
});
|
|
|
|
it('parses location as json card', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'location', data: { lat: '39.9', lon: '116.3', title: 'Beijing' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('json');
|
|
expect(result[0].text).toBeDefined();
|
|
const parsed = JSON.parse(result[0].text!);
|
|
expect(parsed.app).toBe('com.tencent.map');
|
|
expect(parsed.meta.Location.lat).toBe('39.9');
|
|
});
|
|
|
|
it('parses contact as json card', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'contact', data: { type: 'group', id: '12345' } }] as any,
|
|
false,
|
|
);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].type).toBe('json');
|
|
expect(result[0].text).toBeDefined();
|
|
const parsed = JSON.parse(result[0].text!);
|
|
expect(parsed.meta.contact.type).toBe('group');
|
|
});
|
|
});
|
|
|
|
describe('single segment object', () => {
|
|
it('parses single segment object', async () => {
|
|
const result = await parseMessage(
|
|
{ type: 'text', data: { text: 'single' } } as any,
|
|
false,
|
|
);
|
|
expect(result).toEqual([{ type: 'text', text: 'single' }]);
|
|
});
|
|
});
|
|
|
|
describe('edge cases', () => {
|
|
it('returns empty for null', async () => {
|
|
const result = await parseMessage(null as any, false);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('returns empty for number', async () => {
|
|
const result = await parseMessage(42 as any, false);
|
|
expect(result).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('file segment', () => {
|
|
// Closes the parser-side of the "upload says ok but message is
|
|
// empty" bug. Before this, `{type:'file', file_id:'…'}` segments
|
|
// fell through to the default warn-and-drop branch — which made
|
|
// `send_msg([{type:'file', file_id:'<uploaded>'}])` produce either
|
|
// a "message is empty" error or, when mixed with text, a message
|
|
// with the file segment quietly missing.
|
|
it('parses {type:"file", file_id:"x"} into a file MessageElement', async () => {
|
|
const result = await parseMessage(
|
|
[{ type: 'file', data: { file_id: 'fid-1', name: 'a.zip', size: 123 } } as any],
|
|
false,
|
|
);
|
|
expect(result).toEqual([
|
|
{ type: 'file', fileId: 'fid-1', fileName: 'a.zip', fileSize: 123 },
|
|
]);
|
|
});
|
|
|
|
it('drops a file segment with no file_id (upload-first contract)', async () => {
|
|
// Path-only segments aren't supported here — callers must
|
|
// upload via `upload_group_file` / `upload_private_file` first
|
|
// to obtain a file_id. Dropping with a warning is preferable
|
|
// to silently kicking off an upload from inside the message
|
|
// parser, which can't fail loudly without changing call sites.
|
|
const result = await parseMessage(
|
|
[{ type: 'file', data: { file: '/local/path/a.bin' } } as any],
|
|
false,
|
|
);
|
|
expect(result).toEqual([]);
|
|
});
|
|
|
|
it('accepts fileId / filename / fileName / md5 / sha1 aliases', async () => {
|
|
const result = await parseMessage(
|
|
[{
|
|
type: 'file',
|
|
data: { fileId: 'fid-2', filename: 'b.zip', fileSize: 456, md5: 'AB', sha1: 'CD' },
|
|
} as any],
|
|
false,
|
|
);
|
|
expect(result).toEqual([
|
|
{ type: 'file', fileId: 'fid-2', fileName: 'b.zip', fileSize: 456, md5Hex: 'AB', sha1Hex: 'CD' },
|
|
]);
|
|
});
|
|
});
|
|
});
|