From e91a506bf5aa48dd9b088eff0127a65c1322dbdc Mon Sep 17 00:00:00 2001 From: DrSmoothl <1787882683@qq.com> Date: Tue, 12 May 2026 16:21:54 +0800 Subject: [PATCH] feat(onebot): implement forward_{group,friend}_single_msg via md5 fast-upload Captures protocol-level media fingerprints (md5/sha1/dims/format) on the receive side and persists them alongside existing MediaStore entries, so a forward can re-send the original message via QQ's md5 fast-upload path without re-downloading the source CDN bytes. Avoids the stale-rkey trap where the cached imageUrl 404s a few hours after receipt. - MessageElement: add md5Hex / sha1Hex / pic|video|voiceFormat / noByteFallback optional fields. - MediaStore: extend CachedImage / CachedRecord with fingerprints, add CachedVideo + rememberVideo / findVideo / updateVideoUrl. Per-row growth ~80-90 bytes; LRU cap stays at 4096 per type. - msg-push-handler: extract fingerprints from NTV2 image/record/video and legacy NotOnlineImage/CustomFace/Ptt paths. - event-converter: invoke mediaSegmentSink for video too. - highway image/ptt/video upload: add fast-only branch that skips loadBinarySource/encodeSilk/stageVideoSource when noByteFallback is set, and fails fast if the server still returns uKey. Video forward uses the 100-byte FALLBACK_THUMB as its subFile (original thumb not preserved in onebot semantics). - message-actions: add forwardSingleMessage which looks up the cached event, enriches each media element with cached fingerprints, and dispatches via the existing sendGroup/sendPrivateMessage path. Files reject explicitly (separate upload protocol, out of scope). - extended actions: wire forward_friend_single_msg / forward_group_single_msg to the new context method, replacing the not-implemented stubs. --- packages/core/src/bridge/events.ts | 10 ++ .../src/bridge/handlers/msg-push-handler.ts | 19 ++- .../core/src/bridge/highway/image-upload.ts | 44 +++++- .../core/src/bridge/highway/ptt-upload.ts | 51 +++++- .../core/src/bridge/highway/video-upload.ts | 74 ++++++++- packages/core/src/onebot/actions/extended.ts | 28 +++- packages/core/src/onebot/api-handler.ts | 1 + packages/core/src/onebot/event-converter.ts | 13 +- packages/core/src/onebot/instance-context.ts | 2 + packages/core/src/onebot/instance.ts | 31 +++- packages/core/src/onebot/media-store.ts | 53 ++++++- .../src/onebot/modules/message-actions.ts | 146 ++++++++++++++++++ 12 files changed, 447 insertions(+), 25 deletions(-) diff --git a/packages/core/src/bridge/events.ts b/packages/core/src/bridge/events.ts index 3bd23261..75fcdd32 100644 --- a/packages/core/src/bridge/events.ts +++ b/packages/core/src/bridge/events.ts @@ -27,6 +27,16 @@ export interface MessageElement { flash?: boolean; resId?: string; fileHash?: string; + // Server-side fingerprints carried from receive side so a forward can do a + // pure md5/sha1 fast-upload without re-downloading the original bytes. + // Set together with `noByteFallback: true` to make the upload modules throw + // instead of falling back to fetch(url). + md5Hex?: string; + sha1Hex?: string; + picFormat?: number; + videoFormat?: number; + voiceFormat?: number; + noByteFallback?: boolean; mediaNode?: { fileUuid?: string; storeId?: number; diff --git a/packages/core/src/bridge/handlers/msg-push-handler.ts b/packages/core/src/bridge/handlers/msg-push-handler.ts index d8e03a6f..1d07bd1f 100644 --- a/packages/core/src/bridge/handlers/msg-push-handler.ts +++ b/packages/core/src/bridge/handlers/msg-push-handler.ts @@ -217,6 +217,7 @@ function convertElements(elems: ElemDecoded[]): MessageElement[] { height: img.picHeight ?? 0, subType: img.pbRes?.subType ?? 0, summary: img.pbRes?.summary ?? '[image]', + md5Hex: bytesToHex(img.picMd5), }); } } @@ -234,6 +235,7 @@ function convertElements(elems: ElemDecoded[]): MessageElement[] { height: img.height ?? 0, subType: img.pbRes?.subType ?? 0, summary: img.pbRes?.summary ?? '[image]', + md5Hex: bytesToHex(img.md5), }); } } @@ -397,6 +399,9 @@ function convertElements(elems: ElemDecoded[]): MessageElement[] { fileSize: fi.fileSize ?? 0, width: fi.width ?? 0, height: fi.height ?? 0, imageUrl: url, }; + if (fi.fileHash) me.md5Hex = fi.fileHash; + if (fi.fileSha1) me.sha1Hex = fi.fileSha1; + if (fi.type?.picFormat) me.picFormat = fi.type.picFormat; if (info.extBizInfo?.pic) { me.subType = info.extBizInfo.pic.bizType ?? 0; me.summary = info.extBizInfo.pic.textSummary || '[image]'; @@ -408,6 +413,10 @@ function convertElements(elems: ElemDecoded[]): MessageElement[] { type: 'record', fileName: fi.fileName ?? '', fileId: idx.fileUuid ?? '', duration: fi.time ?? 0, fileHash: fi.fileHash ?? '', + fileSize: fi.fileSize ?? 0, + md5Hex: fi.fileHash ?? '', + sha1Hex: fi.fileSha1 ?? '', + voiceFormat: fi.type?.voiceFormat ?? 0, mediaNode: { fileUuid: idx.fileUuid, storeId: idx.storeId, @@ -439,6 +448,11 @@ function convertElements(elems: ElemDecoded[]): MessageElement[] { fileId: idx.fileUuid ?? '', fileSize: fi.fileSize ?? 0, duration: fi.time ?? 0, fileHash: fi.fileHash ?? '', + width: fi.width ?? 0, + height: fi.height ?? 0, + md5Hex: fi.fileHash ?? '', + sha1Hex: fi.fileSha1 ?? '', + videoFormat: fi.type?.videoFormat ?? 0, mediaNode: { fileUuid: idx.fileUuid, storeId: idx.storeId, @@ -490,10 +504,13 @@ function extractRichtextExtras( // Ptt (voice) if (rt.ptt) { const p = rt.ptt; + const md5Hex = p.fileMd5 && p.fileMd5.length > 0 ? bytesToHex(p.fileMd5) : ''; const me: MessageElement = { type: 'record', fileName: p.fileName ?? '', fileSize: p.fileSize ?? 0, duration: p.time ?? 0, - fileHash: p.fileMd5 && p.fileMd5.length > 0 ? bytesToHex(p.fileMd5) : '', + fileHash: md5Hex, + md5Hex, + voiceFormat: p.format ?? 0, }; if (isGroup && (p.fileId ?? 0n) !== 0n) { me.fileId = p.groupFileKey ?? ''; diff --git a/packages/core/src/bridge/highway/image-upload.ts b/packages/core/src/bridge/highway/image-upload.ts index d32c7749..f93154cd 100644 --- a/packages/core/src/bridge/highway/image-upload.ts +++ b/packages/core/src/bridge/highway/image-upload.ts @@ -19,20 +19,57 @@ import { } from './highway-client'; interface ImageData { + /** Empty when the caller is forwarding from cached fingerprints (no bytes path). */ bytes: Uint8Array; md5: Uint8Array; sha1: Uint8Array; md5Hex: string; sha1Hex: string; fileName: string; + fileSize: number; summary: string; subType: number; width: number; height: number; picFormat: number; + /** When true, `bytes` is empty and the upload must fast-path or throw. */ + fastOnly: boolean; +} + +function hexToBytes(hex: string): Uint8Array { + const clean = hex.length % 2 === 0 ? hex : '0' + hex; + const out = new Uint8Array(clean.length / 2); + for (let i = 0; i < out.length; i++) { + out[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16); + } + return out; +} + +function imageDataFromFingerprint(element: MessageElement): ImageData { + return { + bytes: new Uint8Array(0), + md5: hexToBytes(element.md5Hex ?? ''), + sha1: hexToBytes(element.sha1Hex ?? ''), + md5Hex: element.md5Hex ?? '', + sha1Hex: element.sha1Hex ?? '', + fileName: element.fileName || `${element.md5Hex ?? 'image'}.jpg`, + fileSize: element.fileSize ?? 0, + summary: element.summary || (element.subType === 0 ? '[image]' : '[sticker]'), + subType: element.subType ?? 0, + width: element.width ?? 0, + height: element.height ?? 0, + picFormat: element.picFormat ?? 1000, + fastOnly: true, + }; } function loadImage(element: MessageElement): Promise { + if (element.noByteFallback) { + if (!element.md5Hex || !element.sha1Hex) { + return Promise.reject(new Error('image fast-upload requires md5Hex + sha1Hex')); + } + return Promise.resolve(imageDataFromFingerprint(element)); + } return loadImageFromSource( element.url || element.fileId || '', element.fileName ?? '', @@ -59,11 +96,13 @@ async function loadImageFromSource(source: string, fileName: string, subType: nu md5Hex: hashes.md5Hex, sha1Hex: hashes.sha1Hex, fileName: finalName, + fileSize: loaded.bytes.length, summary: summary || (subType === 0 ? '[image]' : '[sticker]'), subType, width: fmt.width, height: fmt.height, picFormat: fmt.format, + fastOnly: false, }; } @@ -84,7 +123,7 @@ async function startImageUpload(bridge: Bridge, isGroup: boolean, targetIdOrUid: upload: { uploadInfo: [{ fileInfo: { - fileSize: image.bytes.length, + fileSize: image.fileSize, fileHash: image.md5Hex, fileSha1: image.sha1Hex, fileName: image.fileName, @@ -185,6 +224,9 @@ export async function uploadImageMsgInfo( // Upload binary if uKey is present (not fast-uploaded) const uKey = upload?.uKey ?? ''; if (uKey && upload?.msgInfo) { + if (image.fastOnly) { + throw new Error('image fast-upload not available (server requires bytes)'); + } const session = await fetchHighwaySession(bridge); const extend = buildHighwayExtend(uKey, upload.msgInfo, upload.ipv4s ?? [], image.sha1); const commandId = isGroup ? GROUP_IMAGE_CMD_ID : PRIVATE_IMAGE_CMD_ID; diff --git a/packages/core/src/bridge/highway/ptt-upload.ts b/packages/core/src/bridge/highway/ptt-upload.ts index a02b2a07..f967b643 100644 --- a/packages/core/src/bridge/highway/ptt-upload.ts +++ b/packages/core/src/bridge/highway/ptt-upload.ts @@ -36,20 +36,58 @@ export const PRIVATE_PTT_CMD_ID = 1007; export const GROUP_PTT_CMD_ID = 1008; interface PttPayload { - /** Silk bytes that get uploaded to highway. */ + /** Silk bytes that get uploaded to highway. Empty when fast-only forward. */ bytes: Uint8Array; md5: Uint8Array; sha1: Uint8Array; md5Hex: string; sha1Hex: string; fileName: string; + fileSize: number; /** Whole seconds, >= 1. */ duration: number; + voiceFormat: number; + /** When true, `bytes` is empty and the upload must fast-path or throw. */ + fastOnly: boolean; /** Cleanup hooks invoked once the OIDB request + highway upload finish. */ cleanups: Array<() => void>; } +function hexToBytes(hex: string): Uint8Array { + const clean = hex.length % 2 === 0 ? hex : '0' + hex; + const out = new Uint8Array(clean.length / 2); + for (let i = 0; i < out.length; i++) { + out[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16); + } + return out; +} + +function pttPayloadFromFingerprint(element: MessageElement): PttPayload { + return { + bytes: new Uint8Array(0), + md5: hexToBytes(element.md5Hex ?? ''), + sha1: hexToBytes(element.sha1Hex ?? ''), + md5Hex: element.md5Hex ?? '', + sha1Hex: element.sha1Hex ?? '', + fileName: element.fileName || `${element.md5Hex ?? 'record'}.amr`, + fileSize: element.fileSize ?? 0, + duration: element.duration ?? 1, + // Voice format: 1 = silk (NTV2 standard). If the original carried a + // different voiceFormat we honour it; the legacy ptt path on NTQQ uses 1. + voiceFormat: element.voiceFormat || 1, + fastOnly: true, + cleanups: [], + }; +} + async function loadPtt(element: MessageElement, tempDir: string): Promise { + if (element.noByteFallback) { + if (!element.md5Hex || !element.sha1Hex) { + throw new Error('record fast-upload requires md5Hex + sha1Hex'); + } + return pttPayloadFromFingerprint(element); + } + const source = element.url || element.fileId || ''; if (!source) throw new Error('record source is empty'); @@ -97,7 +135,10 @@ async function loadPtt(element: MessageElement, tempDir: string): Promise void>; } +function hexToBytes(hex: string): Uint8Array { + const clean = hex.length % 2 === 0 ? hex : '0' + hex; + const out = new Uint8Array(clean.length / 2); + for (let i = 0; i < out.length; i++) { + out[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16); + } + return out; +} + +function makeFallbackThumb(): ThumbPayload { + const bytes = new Uint8Array(FALLBACK_THUMB); + const hashes = computeHashes(bytes); + return { + bytes, + md5: hashes.md5, + sha1: hashes.sha1, + md5Hex: hashes.md5Hex, + sha1Hex: hashes.sha1Hex, + width: 1, + height: 1, + }; +} + +function videoPayloadFromFingerprint(element: MessageElement): VideoPayload { + return { + bytes: new Uint8Array(0), + md5: hexToBytes(element.md5Hex ?? ''), + sha1: hexToBytes(element.sha1Hex ?? ''), + sha1Blocks: [], + md5Hex: element.md5Hex ?? '', + sha1Hex: element.sha1Hex ?? '', + fileName: element.fileName || `${element.md5Hex ?? 'video'}.mp4`, + filePath: '', + fileSize: element.fileSize ?? 0, + width: element.width ?? 0, + height: element.height ?? 0, + duration: element.duration ?? 1, + videoFormat: element.videoFormat ?? 0, + thumb: makeFallbackThumb(), + fastOnly: true, + cleanups: [], + }; +} + interface ThumbPayload { bytes: Uint8Array; md5: Uint8Array; @@ -321,6 +372,13 @@ async function loadThumb(element: MessageElement, videoPath: string): Promise<{ } async function loadVideo(element: MessageElement): Promise { + if (element.noByteFallback) { + if (!element.md5Hex || !element.sha1Hex) { + throw new Error('video fast-upload requires md5Hex + sha1Hex'); + } + return videoPayloadFromFingerprint(element); + } + const tempDir = defaultVideoTempDir(); const cleanups: Array<() => void> = []; fs.mkdirSync(tempDir, { recursive: true }); @@ -344,10 +402,13 @@ async function loadVideo(element: MessageElement): Promise { sha1Hex: hashes.sha1Hex, fileName: staged.fileName || `${hashes.md5Hex}.mp4`, filePath: staged.filePath, + fileSize: staged.bytes.length, width, height, duration, + videoFormat: 0, thumb, + fastOnly: false, cleanups: [...cleanups], }; } catch (err) { @@ -381,14 +442,14 @@ async function startVideoUpload( uploadInfo: [ { fileInfo: { - fileSize: video.bytes.length, + fileSize: video.fileSize, fileHash: video.md5Hex, fileSha1: video.sha1Hex, fileName: 'nya.mp4', - type: { type: 2, picFormat: 0, videoFormat: 0, voiceFormat: 0 }, - height: 0, - width: 0, - time: 0, + type: { type: 2, picFormat: 0, videoFormat: video.videoFormat, voiceFormat: 0 }, + height: video.height, + width: video.width, + time: video.duration, original: 0, }, subFileType: 0, @@ -493,6 +554,9 @@ export async function uploadVideoMsgInfo( const uKey = upload?.uKey ?? ''; if (uKey && upload?.msgInfo) { + if (video.fastOnly) { + throw new Error('video fast-upload not available (server requires bytes)'); + } log.debug('highway video upload: bytes=%d md5=%s scene=%s', video.bytes.length, video.md5Hex, isGroup ? 'group' : 'c2c'); const extend = buildHighwayExtend(uKey, upload.msgInfo, upload.ipv4s ?? [], video.sha1Blocks, 0); const commandId = isGroup ? GROUP_VIDEO_CMD_ID : PRIVATE_VIDEO_CMD_ID; diff --git a/packages/core/src/onebot/actions/extended.ts b/packages/core/src/onebot/actions/extended.ts index 04d39cde..0f383c97 100644 --- a/packages/core/src/onebot/actions/extended.ts +++ b/packages/core/src/onebot/actions/extended.ts @@ -623,12 +623,32 @@ export function register(h: ApiHandler, ctx: ApiActionContext): void { return okResponse([]); }); - h.registerAction('forward_friend_single_msg', async () => { - return failedResponse(RETCODE.ACTION_FAILED, 'not yet implemented'); + h.registerAction('forward_friend_single_msg', async (params) => { + const messageId = asNumber(params.message_id); + const userId = asNumber(params.user_id); + if (!messageId) return failedResponse(RETCODE.BAD_REQUEST, 'message_id is required'); + if (!userId) return failedResponse(RETCODE.BAD_REQUEST, 'user_id is required'); + if (!ctx.forwardSingleMsg) return failedResponse(RETCODE.ACTION_FAILED, 'not implemented'); + try { + const result = await ctx.forwardSingleMsg(messageId, { userId }); + return okResponse({ message_id: result.messageId }); + } catch (err) { + return failedResponse(RETCODE.ACTION_FAILED, err instanceof Error ? err.message : String(err)); + } }); - h.registerAction('forward_group_single_msg', async () => { - return failedResponse(RETCODE.ACTION_FAILED, 'not yet implemented'); + h.registerAction('forward_group_single_msg', async (params) => { + const messageId = asNumber(params.message_id); + const groupId = asNumber(params.group_id); + if (!messageId) return failedResponse(RETCODE.BAD_REQUEST, 'message_id is required'); + if (!groupId) return failedResponse(RETCODE.BAD_REQUEST, 'group_id is required'); + if (!ctx.forwardSingleMsg) return failedResponse(RETCODE.ACTION_FAILED, 'not implemented'); + try { + const result = await ctx.forwardSingleMsg(messageId, { groupId }); + return okResponse({ message_id: result.messageId }); + } catch (err) { + return failedResponse(RETCODE.ACTION_FAILED, err instanceof Error ? err.message : String(err)); + } }); // todo 我的建议是引入数据库api 纯协议我不知道这种api怎么实现,ntQQ在实现这个方法的时候只进行了数据库查询,完全没碰网络 diff --git a/packages/core/src/onebot/api-handler.ts b/packages/core/src/onebot/api-handler.ts index 5e1e3022..5a812521 100644 --- a/packages/core/src/onebot/api-handler.ts +++ b/packages/core/src/onebot/api-handler.ts @@ -101,6 +101,7 @@ export interface ApiActionContext { sendPrivateForwardMsg?: (userId: number, messages: JsonValue) => Promise<{ messageId: number; forwardId: string }>; sendForwardMsg?: (messages: JsonValue) => Promise<{ forwardId: string }>; getForwardMsg?: (resId: string) => Promise; + forwardSingleMsg?: (messageId: number, target: { groupId?: number; userId?: number }) => Promise<{ messageId: number }>; // Extended NapCat-compatible setFriendRemark?: (userId: number, remark: string) => Promise; setGroupRemark?: (groupId: number, remark: string) => Promise; diff --git a/packages/core/src/onebot/event-converter.ts b/packages/core/src/onebot/event-converter.ts index b8dc538f..fc3f3c77 100644 --- a/packages/core/src/onebot/event-converter.ts +++ b/packages/core/src/onebot/event-converter.ts @@ -11,7 +11,7 @@ export type MessageIdResolver = (isGroup: boolean, sessionId: number, sequence: * `get_record`) without having to re-scan the persisted message store. */ export type MediaSegmentSink = ( - mediaType: 'image' | 'record', + mediaType: 'image' | 'record' | 'video', element: MessageElement, data: JsonObject, isGroup: boolean, @@ -414,13 +414,12 @@ async function elementToSegment( if (element.type === 'video') { const url = mediaResolver ? await mediaResolver(element, isGroup, sessionId) : (element.url ?? ''); - return { - type: 'video', - data: { - file: element.fileName ?? element.fileId ?? '', - url, - }, + const data: JsonObject = { + file: element.fileName ?? element.fileId ?? '', + url, }; + if (mediaSink) mediaSink('video', element, data, isGroup, sessionId); + return { type: 'video', data }; } if (element.type === 'json') { diff --git a/packages/core/src/onebot/instance-context.ts b/packages/core/src/onebot/instance-context.ts index 57f1c309..d08cb6de 100644 --- a/packages/core/src/onebot/instance-context.ts +++ b/packages/core/src/onebot/instance-context.ts @@ -20,6 +20,7 @@ import { } from './modules/contact-actions'; import { deleteMessage, + forwardSingleMessage, getForwardMessage, getFriendMsgHistory, getGroupMsgHistory, @@ -166,6 +167,7 @@ export function buildApiContext(ref: OneBotInstanceContext): ApiActionContext { sendPrivateForwardMsg: (userId, messages) => sendPrivateForwardMessage(ref, userId, messages), sendForwardMsg: (messages) => uploadForwardMessage(ref, messages), getForwardMsg: (resId) => getForwardMessage(ref, resId), + forwardSingleMsg: (messageId, target) => forwardSingleMessage(ref, messageId, target), forceFetchClientKey: () => bridge.forceFetchClientKey(), setFriendRemark: (userId, remark) => bridge.setFriendRemark(userId, remark), setGroupRemark: (groupId, remark) => bridge.setGroupRemark(groupId, remark), diff --git a/packages/core/src/onebot/instance.ts b/packages/core/src/onebot/instance.ts index 1c5d0d97..e4535f64 100644 --- a/packages/core/src/onebot/instance.ts +++ b/packages/core/src/onebot/instance.ts @@ -91,10 +91,34 @@ export class OneBotInstance { imageUrl: element.imageUrl ?? '', isGroup, sessionId, + md5Hex: element.md5Hex, + sha1Hex: element.sha1Hex, + width: element.width, + height: element.height, + picFormat: element.picFormat, }); return; } - this.mediaStore.rememberRecord({ + if (mediaType === 'record') { + this.mediaStore.rememberRecord({ + file: file || element.fileName || element.fileId || '', + fileId: element.fileId ?? '', + url, + fileSize: element.fileSize ?? 0, + fileName: element.fileName ?? '', + duration: element.duration ?? 0, + fileHash: element.fileHash ?? '', + mediaNode: element.mediaNode, + isGroup, + sessionId, + md5Hex: element.md5Hex, + sha1Hex: element.sha1Hex, + voiceFormat: element.voiceFormat, + }); + return; + } + // video + this.mediaStore.rememberVideo({ file: file || element.fileName || element.fileId || '', fileId: element.fileId ?? '', url, @@ -105,6 +129,11 @@ export class OneBotInstance { mediaNode: element.mediaNode, isGroup, sessionId, + md5Hex: element.md5Hex, + sha1Hex: element.sha1Hex, + width: element.width, + height: element.height, + videoFormat: element.videoFormat, }); }); this.eventConverter.setMessageIdResolver((isGroup, sessionId, sequence, eventName) => diff --git a/packages/core/src/onebot/media-store.ts b/packages/core/src/onebot/media-store.ts index f0b8e60c..95a17093 100644 --- a/packages/core/src/onebot/media-store.ts +++ b/packages/core/src/onebot/media-store.ts @@ -38,6 +38,13 @@ export interface CachedImage { sessionId: number; /** Original imageUrl from the MessageElement, used for RKey re-appending. */ imageUrl: string; + /** Fingerprints used for md5/sha1 fast-upload on forward. Optional because + * legacy CustomFace / NotOnlineImage only carry md5. */ + md5Hex?: string; + sha1Hex?: string; + width?: number; + height?: number; + picFormat?: number; } export interface CachedRecord { @@ -56,10 +63,34 @@ export interface CachedRecord { /** Conversation the media originated from (group vs private path). */ isGroup: boolean; sessionId: number; + /** Fingerprints used for md5/sha1 fast-upload on forward. */ + md5Hex?: string; + sha1Hex?: string; + voiceFormat?: number; +} + +export interface CachedVideo { + file: string; + fileId: string; + url: string; + fileSize: number; + fileName: string; + duration: number; + fileHash: string; + mediaNode?: MessageElement['mediaNode']; + isGroup: boolean; + sessionId: number; + /** Fingerprints used for md5/sha1 fast-upload on forward. */ + md5Hex?: string; + sha1Hex?: string; + width?: number; + height?: number; + videoFormat?: number; } const TYPE_IMAGE = 'image'; const TYPE_RECORD = 'record'; +const TYPE_VIDEO = 'video'; const DEFAULT_KEEP_ENTRIES = 4096; export class MediaStore { @@ -145,6 +176,12 @@ export class MediaStore { this.upsertWithAliases(TYPE_RECORD, primaryKey, info, [info.file, info.fileName, info.fileId, info.url]); } + rememberVideo(info: CachedVideo): void { + const primaryKey = pickPrimary([info.file, info.fileName, info.fileId]); + if (!primaryKey) return; + this.upsertWithAliases(TYPE_VIDEO, primaryKey, info, [info.file, info.fileName, info.fileId, info.url]); + } + findImage(key: string): CachedImage | null { return this.findByAnyKey(TYPE_IMAGE, key); } @@ -153,6 +190,10 @@ export class MediaStore { return this.findByAnyKey(TYPE_RECORD, key); } + findVideo(key: string): CachedVideo | null { + return this.findByAnyKey(TYPE_VIDEO, key); + } + updateImageUrl(key: string, url: string): void { if (!url) return; const cached = this.findImage(key); @@ -167,11 +208,19 @@ export class MediaStore { this.rememberRecord({ ...cached, url }); } + updateVideoUrl(key: string, url: string): void { + if (!url) return; + const cached = this.findVideo(key); + if (!cached || cached.url === url) return; + this.rememberVideo({ ...cached, url }); + } + /** Snapshot count of distinct entries per type; mostly used by tests. */ - size(): { images: number; records: number } { + size(): { images: number; records: number; videos: number } { const img = this.countByType.get(TYPE_IMAGE) as { n: number } | undefined; const rec = this.countByType.get(TYPE_RECORD) as { n: number } | undefined; - return { images: img?.n ?? 0, records: rec?.n ?? 0 }; + const vid = this.countByType.get(TYPE_VIDEO) as { n: number } | undefined; + return { images: img?.n ?? 0, records: rec?.n ?? 0, videos: vid?.n ?? 0 }; } // --- internals --- diff --git a/packages/core/src/onebot/modules/message-actions.ts b/packages/core/src/onebot/modules/message-actions.ts index b4e256e6..9d63d626 100644 --- a/packages/core/src/onebot/modules/message-actions.ts +++ b/packages/core/src/onebot/modules/message-actions.ts @@ -235,6 +235,152 @@ export async function uploadForwardMessage( return { forwardId }; } +/** + * Forward a previously-received message to another peer. + * + * We look up the cached event + media fingerprints, then re-send via the + * normal send pipeline with `noByteFallback` set on media elements so the + * upload modules fast-path through OIDB md5/sha1 instead of re-downloading + * the original CDN bytes. Fails fast if a media segment has no cached + * fingerprints or contains a file segment (file forwarding has its own + * separate protocol and is not in scope here). + */ +export async function forwardSingleMessage( + ref: OneBotInstanceContext, + messageId: number, + target: { groupId?: number; userId?: number }, +): Promise<{ messageId: number }> { + if (!target.groupId && !target.userId) { + throw new Error('forward target group_id or user_id is required'); + } + + const event = ref.messageStore.findEvent(messageId); + if (!event) throw new Error(`message not found: ${messageId}`); + + const content = (event.message ?? event.raw_message ?? '') as JsonValue; + const parsed = await parseMessage(content, false); + if (parsed.length === 0) throw new Error('message has no content'); + + const elements = parsed.map((el) => enrichForForward(ref, el)); + + let receipt; + let messageIdOut: number; + if (target.groupId) { + receipt = await ref.bridge.sendGroupMessage(target.groupId, elements); + messageIdOut = hashMessageIdInt32(receipt.sequence, target.groupId, GROUP_MESSAGE_EVENT); + ref.cacheMessageMeta(messageIdOut, { + isGroup: true, + targetId: target.groupId, + sequence: receipt.sequence, + eventName: GROUP_MESSAGE_EVENT, + clientSequence: receipt.clientSequence, + random: receipt.random, + timestamp: receipt.timestamp, + }); + } else { + receipt = await ref.bridge.sendPrivateMessage(target.userId!, elements); + messageIdOut = hashMessageIdInt32(receipt.sequence, target.userId!, PRIVATE_MESSAGE_EVENT); + ref.cacheMessageMeta(messageIdOut, { + isGroup: false, + targetId: target.userId!, + sequence: receipt.sequence, + eventName: PRIVATE_MESSAGE_EVENT, + clientSequence: receipt.clientSequence, + random: receipt.random, + timestamp: receipt.timestamp, + }); + } + + return { messageId: messageIdOut }; +} + +function enrichForForward(ref: OneBotInstanceContext, element: MessageElement): MessageElement { + // The send path takes care of these as-is; nothing extra to do. + if (element.type === 'text' || element.type === 'face' || element.type === 'at' + || element.type === 'reply' || element.type === 'json' || element.type === 'xml' + || element.type === 'poke' || element.type === 'forward' || element.type === 'mface') { + return element; + } + + // The `file` segment is its own upload pipeline (FtnUpload / OfflineFile) + // and is not supported by the fast-upload forward path. + if (element.type === 'file') { + throw new Error('forward of file segment is not supported'); + } + + // For images/records/videos we look up the cached fingerprints by any of + // the keys MediaStore aliases under. After parseMessage, the segment's + // `data.file` lands on `element.url` for all three types. + const lookupKey = element.url || element.fileName || element.fileId || ''; + if (!lookupKey) { + throw new Error(`forward ${element.type} missing cache key`); + } + + if (element.type === 'image') { + const cached = ref.mediaStore.findImage(lookupKey); + if (!cached || !cached.md5Hex || !cached.sha1Hex || !cached.width || !cached.height || !cached.picFormat) { + throw new Error('forward image fingerprint not cached (legacy image or expired)'); + } + return { + ...element, + type: 'image', + noByteFallback: true, + md5Hex: cached.md5Hex, + sha1Hex: cached.sha1Hex, + fileSize: cached.fileSize, + fileName: cached.fileName, + subType: cached.subType, + summary: cached.summary, + width: cached.width, + height: cached.height, + picFormat: cached.picFormat, + }; + } + + if (element.type === 'record') { + const cached = ref.mediaStore.findRecord(lookupKey); + if (!cached || !cached.md5Hex || !cached.sha1Hex) { + throw new Error('forward record fingerprint not cached'); + } + return { + ...element, + type: 'record', + noByteFallback: true, + md5Hex: cached.md5Hex, + sha1Hex: cached.sha1Hex, + fileSize: cached.fileSize, + fileName: cached.fileName, + fileId: cached.fileId, + duration: cached.duration, + voiceFormat: cached.voiceFormat ?? 1, + }; + } + + if (element.type === 'video') { + const cached = ref.mediaStore.findVideo(lookupKey); + if (!cached || !cached.md5Hex || !cached.sha1Hex) { + throw new Error('forward video fingerprint not cached'); + } + log.warn('video forward uses a fallback thumbnail (original thumb not cached)'); + return { + ...element, + type: 'video', + noByteFallback: true, + md5Hex: cached.md5Hex, + sha1Hex: cached.sha1Hex, + fileSize: cached.fileSize, + fileName: cached.fileName, + fileId: cached.fileId, + duration: cached.duration, + width: cached.width ?? 0, + height: cached.height ?? 0, + videoFormat: cached.videoFormat ?? 0, + }; + } + + return element; +} + export async function getForwardMessage( ref: OneBotInstanceContext, resId: string,