SnowLuma v2.4.2 source snapshot

packages/core/tests/actions/forward-file.test.ts

@@ -0,0 +1,588 @@
+// Regression coverage for the file-inside-send_forward_msg bug.
+//
+// Symptom: caller put `{type:'file', file_id}` inside a forward node;
+// the element-builder dropped it (`[ElemBuilder] BUG: {type:"file"}
+// reached element-builder — must be split out at the OneBot layer`)
+// because the live-send paths route files through dedicated methods
+// (sendC2cFileMessage / sendGroupFileMessage), and the forward
+// builder was naïvely calling buildSendElems with the same ctx. The
+// forward upload succeeded but the bubble shipped without the file
+// element.
+//
+// Fix: forward upload passes `forwardFake: true` on the SendContext.
+// The element-builder honours that flag by emitting the receive-side
+// shapes:
+//   * group file → transElem(elemType=24, GroupFileExtra)
+//   * c2c file   → handled at the forward-builder level, written into
+//                  `body.msgContent` as FileExtra { file: NotOnlineFile }
+//
+// These shapes are RECEIVE-side: the QQ-NT live-send pipeline rejects
+// transElem(24) (result=79), but the long-msg upload service stores the
+// gzipped protobuf verbatim and the recipient's msg-push decoder pulls
+// the file entity back out via the normal path (rich-body-decoder.ts).
+// Mirrors NapCat's `PacketMsgFileElement.{buildElement,buildContent}`
+// split.
+
+import { describe, it, expect, vi } from 'vitest';
+import { gunzipSync } from 'zlib';
+
+vi.mock('@snowluma/protocol/bridge-oidb', () => ({
+    makeOidbEnvelope: vi.fn((_oidbCmd, _subCmd, body) => ({ body })),
+    encodeOidbEnv: vi.fn(() => new Uint8Array()),
+    decodeOidbEnv: vi.fn(() => ({ body: {} })),
+}));
+
+// `vi.mock` factories are hoisted above the imports — declare the spy
+// inside a `vi.hoisted` block so it's available at the same moment.
+// Declare parameter types on the fn so `mock.calls[0]` infers a tuple
+// of [elements, ctx] instead of `[]`, which makes the destructuring
+// a tsc error under strict tuple checking on CI.
+const { buildSendElemsMock } = vi.hoisted(() => ({
+    buildSendElemsMock: vi.fn(async (_elements: unknown[], _ctx?: Record<string, unknown>) => []),
+}));
+vi.mock('@snowluma/protocol/element-builder', () => ({
+    buildSendElems: buildSendElemsMock,
+}));
+
+import { protobuf_decode, protobuf_encode } from '@snowluma/proton';
+import type { LongMsgResult, SendLongMsgReq, SendLongMsgResp } from '@snowluma/proto-defs/longmsg';
+import type { FileExtra } from '@snowluma/proto-defs/message';
+import { ForwardApi } from '../../src/bridge/apis/forward';
+import { mockBridge } from './_helpers';
+
+function uploadResponseWithResId(resId: string) {
+    const encoded = protobuf_encode<SendLongMsgResp>({ result: { resId } });
+    return {
+        success: true,
+        gotResponse: true,
+        errorCode: 0,
+        errorMessage: '',
+        responseData: Buffer.from(encoded),
+    };
+}
+
+function decodeLongMsgRequest(rawBytes: Uint8Array): LongMsgResult {
+    const env = protobuf_decode<SendLongMsgReq>(rawBytes);
+    const payload = env.info?.payload;
+
+    if (!(payload instanceof Uint8Array)) {
+        throw new Error('payload missing on SendLongMsgReq');
+    }
+
+    return protobuf_decode<LongMsgResult>(gunzipSync(Buffer.from(payload)));
+}
+
+describe('actions/forward — file segment inside forward node', () => {
+    it('rejects cached temporary files mixed with text before building a forward payload', async () => {
+        buildSendElemsMock.mockClear();
+        const bridge = mockBridge({
+            recallUploadedFile: vi.fn(() => ({ scope: 'group', groupId: 12345, busId: 104 })),
+        });
+        await expect(
+            new ForwardApi(bridge as any).upload(
+                [
+                    {
+                        userUin: 10001,
+                        nickname: 'alice',
+                        elements: [
+                            { type: 'text', text: 'caption' },
+                            { type: 'file', fileId: 'temp' },
+                        ],
+                    },
+                ],
+                12345,
+            ),
+        ).rejects.toThrow(/temporary group files.*only file or image/i);
+        expect(buildSendElemsMock).not.toHaveBeenCalled();
+        expect(bridge.sendRawPacket).not.toHaveBeenCalled();
+    });
+
+    it('disallows temporary fallback when a forward node mixes a new file with text', async () => {
+        buildSendElemsMock.mockClear();
+        const bridge = mockBridge();
+        bridge.apis.groupFile.upload.mockRejectedValueOnce(
+            new Error('temporary group files require only file or image segments'),
+        );
+        await expect(
+            new ForwardApi(bridge as any).upload(
+                [
+                    {
+                        userUin: 10001,
+                        nickname: 'alice',
+                        elements: [
+                            { type: 'text', text: 'caption' },
+                            { type: 'file', url: 'base64://AQID', fileName: 'note.txt' },
+                        ],
+                    },
+                ],
+                12345,
+            ),
+        ).rejects.toThrow(/temporary group files/);
+        expect(bridge.apis.groupFile.upload).toHaveBeenCalledWith(
+            12345,
+            'base64://AQID',
+            'note.txt',
+            '/',
+            true,
+            false,
+            { allowTemporary: false },
+        );
+        expect(buildSendElemsMock).not.toHaveBeenCalled();
+        expect(bridge.sendRawPacket).not.toHaveBeenCalled();
+    });
+
+    it('rejects a recursive window shake before identity resolution or upload', async () => {
+        buildSendElemsMock.mockClear();
+        const resolveUserUid = vi.fn();
+        const uploadPrivate = vi.fn();
+        const sendRawPacket = vi.fn();
+        const bridge = mockBridge({
+            resolveUserUid,
+            sendRawPacket: sendRawPacket as any,
+            apis: {
+                ...mockBridge().apis,
+                groupFile: {
+                    ...mockBridge().apis.groupFile,
+                    uploadPrivate,
+                },
+            },
+        });
+
+        await expect(
+            new ForwardApi(bridge as any).upload(
+                [
+                    {
+                        userUin: 10001,
+                        nickname: 'alice',
+                        elements: [{ type: 'image', url: 'base64://AQID' }],
+                        innerForward: [
+                            {
+                                userUin: 10002,
+                                nickname: 'bob',
+                                elements: [{ type: 'poke', subType: 1 }],
+                            },
+                        ],
+                    },
+                ],
+                undefined,
+                67890,
+            ),
+        ).rejects.toMatchObject({
+            code: 'UNSENDABLE_TYPE',
+            elementType: 'poke',
+        });
+
+        expect(resolveUserUid).not.toHaveBeenCalled();
+        expect(uploadPrivate).not.toHaveBeenCalled();
+        expect(buildSendElemsMock).not.toHaveBeenCalled();
+        expect(sendRawPacket).not.toHaveBeenCalled();
+    });
+
+    it('group forward sets forwardFake:true on the SendContext so transElem(24) is emitted', async () => {
+        // Group case: the file element rides on elems[] as transElem(24).
+        // The element-builder receives ctx.forwardFake=true so it knows to
+        // emit the receive-side shape instead of dropping the segment.
+        buildSendElemsMock.mockClear();
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async () => uploadResponseWithResId('res-grp-file')) as any,
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [
+                        { type: 'file', fileId: 'gfid-1', fileName: 'a.txt', fileSize: 99 } as any,
+                    ],
+                },
+            ],
+            12345,
+        );
+
+        expect(buildSendElemsMock).toHaveBeenCalled();
+        const [, ctx] = buildSendElemsMock.mock.calls[0]!;
+        expect(ctx).toMatchObject({ groupId: 12345, forwardFake: true });
+    });
+
+    it('c2c forward writes the file as msgContent (FileExtra { file: NotOnlineFile })', async () => {
+        // Private case: c2c files live on `body.msgContent`, not in elems[].
+        // The forward-builder pulls the file segment off and synthesises a
+        // FileExtra payload so the recipient's decoder (which reads
+        // msgContent first) renders the file bubble.
+        buildSendElemsMock.mockClear();
+        let captured: Uint8Array | undefined;
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async (_cmd: string, body: Uint8Array) => {
+                captured = body;
+                return uploadResponseWithResId('res-c2c-file');
+            }) as any,
+            // Inline fields cover everything we need; cache lookup must not be
+            // required for the path to work.
+            recallUploadedFile: vi.fn(() => undefined),
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [
+                        {
+                            type: 'file',
+                            fileId: 'pfid-1',
+                            fileName: 'invoice.pdf',
+                            fileSize: 4096,
+                            md5Hex: 'aabbccddeeff00112233445566778899',
+                            fileHash: 'srv-hash-abc',
+                        } as any,
+                    ],
+                },
+            ],
+            undefined,
+            67890,
+        );
+
+        expect(buildSendElemsMock).toHaveBeenCalled();
+        const [, ctx] = buildSendElemsMock.mock.calls[0]!;
+        expect(ctx).toMatchObject({ forwardFake: true });
+        expect(ctx?.groupId).toBeUndefined();
+
+        expect(captured).toBeDefined();
+        const longMsg = decodeLongMsgRequest(captured!);
+        const body = longMsg.action?.[0]?.actionData?.msgBody?.[0]?.body;
+        expect(body?.msgContent).toBeInstanceOf(Uint8Array);
+        expect(body?.richText?.notOnlineFile ?? undefined).toBeUndefined();
+
+        const fileExtra = protobuf_decode<FileExtra>(body!.msgContent as Uint8Array);
+        expect(fileExtra.file).toMatchObject({
+            fileUuid: 'pfid-1',
+            fileName: 'invoice.pdf',
+            fileHash: 'srv-hash-abc',
+        });
+        expect(fileExtra.file?.fileSize).toBe(4096n);
+    });
+
+    it('c2c forward falls back to the upload metadata cache when inline fields are missing', async () => {
+        // The OneBot caller often passes only `file_id` — the rest comes
+        // from the bridge's uploaded-file cache. This is the same
+        // hydration path send_private_msg uses; the forward builder must
+        // honour it too or every cached-only forward ships a 0 B bubble.
+        buildSendElemsMock.mockClear();
+        const recallUploadedFile = vi.fn((id: string) =>
+            id === 'pfid-cached'
+                ? {
+                      fileId: 'pfid-cached',
+                      scope: 'private' as const,
+                      userId: 67890,
+                      fileName: 'cached-name.zip',
+                      fileSize: 8192,
+                      fileMd5: Buffer.from('ffeeddccbbaa99887766554433221100', 'hex'),
+                      fileSha1: new Uint8Array(20),
+                      fileHash: 'cached-hash',
+                      rememberedAt: 0,
+                  }
+                : undefined,
+        );
+
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async () => uploadResponseWithResId('res-cache')) as any,
+            recallUploadedFile,
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [{ type: 'file', fileId: 'pfid-cached' } as any],
+                },
+            ],
+            undefined,
+            67890,
+        );
+
+        expect(recallUploadedFile).toHaveBeenCalledWith('pfid-cached');
+    });
+
+    it('group forward pre-uploads file sources into the target group without publishing a separate file message', async () => {
+        buildSendElemsMock.mockClear();
+        const upload = vi.fn(async () => ({ fileId: 'gfid-from-base64' }));
+        const publish = vi.fn();
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async () => uploadResponseWithResId('res-grp-source')) as any,
+            apis: {
+                ...mockBridge().apis,
+                groupFile: {
+                    ...mockBridge().apis.groupFile,
+                    upload,
+                    publish,
+                },
+            },
+            recallUploadedFile: vi.fn((id: string) =>
+                id === 'gfid-from-base64'
+                    ? {
+                          fileId: 'gfid-from-base64',
+                          scope: 'group' as const,
+                          groupId: 12345,
+                          fileName: 'note.txt',
+                          fileSize: 3,
+                          fileMd5: new Uint8Array(16),
+                          fileSha1: new Uint8Array(20),
+                          rememberedAt: 0,
+                      }
+                    : undefined,
+            ),
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [{ type: 'file', url: 'base64://AQID', fileName: 'note.txt' } as any],
+                },
+            ],
+            12345,
+        );
+
+        expect(upload).toHaveBeenCalledWith(12345, 'base64://AQID', 'note.txt', '/', true, false, {
+            allowTemporary: true,
+        });
+        expect(publish).not.toHaveBeenCalled();
+        const [elements] = buildSendElemsMock.mock.calls[0]!;
+        expect(elements).toEqual([
+            expect.objectContaining({
+                type: 'file',
+                fileId: 'gfid-from-base64',
+                fileName: 'note.txt',
+                fileSize: 3,
+            }),
+        ]);
+    });
+
+    it('private forward pre-uploads file sources without sending a standalone c2c file message', async () => {
+        buildSendElemsMock.mockClear();
+        const uploadPrivate = vi.fn(async () => ({
+            fileId: 'pfid-from-base64',
+            fileHash: 'phash',
+        }));
+        const sendC2cFile = vi.fn();
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async () => uploadResponseWithResId('res-c2c-source')) as any,
+            apis: {
+                ...mockBridge().apis,
+                message: {
+                    ...mockBridge().apis.message,
+                    sendC2cFile,
+                },
+                groupFile: {
+                    ...mockBridge().apis.groupFile,
+                    uploadPrivate,
+                },
+            },
+            recallUploadedFile: vi.fn((id: string) =>
+                id === 'pfid-from-base64'
+                    ? {
+                          fileId: 'pfid-from-base64',
+                          scope: 'private' as const,
+                          userId: 67890,
+                          fileName: 'note.txt',
+                          fileSize: 3,
+                          fileMd5: new Uint8Array(16),
+                          fileSha1: new Uint8Array(20),
+                          fileHash: 'phash',
+                          rememberedAt: 0,
+                      }
+                    : undefined,
+            ),
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [{ type: 'file', url: 'base64://AQID', fileName: 'note.txt' } as any],
+                },
+            ],
+            undefined,
+            67890,
+        );
+
+        expect(uploadPrivate).toHaveBeenCalledWith(67890, 'base64://AQID', 'note.txt', true, false);
+        expect(sendC2cFile).not.toHaveBeenCalled();
+        const [elements] = buildSendElemsMock.mock.calls[0]!;
+        expect(elements).toEqual([
+            expect.objectContaining({
+                type: 'file',
+                fileId: 'pfid-from-base64',
+                fileName: 'note.txt',
+                fileSize: 3,
+                fileHash: 'phash',
+            }),
+        ]);
+    });
+
+    it('rejects two files in one private forward node before uploading either file', async () => {
+        buildSendElemsMock.mockClear();
+        const uploadPrivate = vi.fn();
+        const sendRawPacket = vi.fn();
+        const bridge = mockBridge({
+            sendRawPacket: sendRawPacket as any,
+            apis: {
+                ...mockBridge().apis,
+                groupFile: {
+                    ...mockBridge().apis.groupFile,
+                    uploadPrivate,
+                },
+            },
+        });
+
+        await expect(
+            new ForwardApi(bridge as any).upload(
+                [
+                    {
+                        userUin: 10001,
+                        nickname: 'alice',
+                        elements: [
+                            { type: 'file', url: 'base64://AQID', fileName: 'one.txt' },
+                            { type: 'file', url: 'base64://BAUG', fileName: 'two.txt' },
+                        ] as any,
+                    },
+                ],
+                undefined,
+                67890,
+            ),
+        ).rejects.toMatchObject({
+            code: 'UNSENDABLE_TYPE',
+            elementType: 'file',
+        });
+
+        expect(uploadPrivate).not.toHaveBeenCalled();
+        expect(buildSendElemsMock).not.toHaveBeenCalled();
+        expect(sendRawPacket).not.toHaveBeenCalled();
+    });
+
+    it('private file forward keeps the long-msg upload under the self uid namespace', async () => {
+        buildSendElemsMock.mockClear();
+        let captured: Uint8Array | undefined;
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async (_cmd: string, body: Uint8Array) => {
+                captured = body;
+                return uploadResponseWithResId('res-c2c-target-uid');
+            }) as any,
+            resolveUserUid: vi.fn(async () => 'target-uid'),
+            recallUploadedFile: vi.fn((id: string) =>
+                id === 'pfid-1'
+                    ? {
+                          fileId: 'pfid-1',
+                          scope: 'private' as const,
+                          userId: 67890,
+                          fileName: 'invoice.pdf',
+                          fileSize: 4096,
+                          fileMd5: new Uint8Array(16),
+                          fileSha1: new Uint8Array(20),
+                          fileHash: 'srv-hash',
+                          rememberedAt: 0,
+                      }
+                    : undefined,
+            ),
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [{ type: 'file', fileId: 'pfid-1' } as any],
+                },
+            ],
+            undefined,
+            67890,
+        );
+
+        expect(bridge.resolveUserUid).not.toHaveBeenCalled();
+        expect(captured).toBeDefined();
+        const request = protobuf_decode<SendLongMsgReq>(captured!);
+        expect(request.info?.uid?.uid).toBe('self-uid');
+    });
+
+    it('group forward re-uploads a cached private file_id into the target group scope', async () => {
+        buildSendElemsMock.mockClear();
+        const getPrivateUrl = vi.fn(async () => 'https://download.test/private-file');
+        const upload = vi.fn(async () => ({ fileId: 'gfid-reuploaded' }));
+        const bridge = mockBridge({
+            sendRawPacket: vi.fn(async () => uploadResponseWithResId('res-cross-scope')) as any,
+            apis: {
+                ...mockBridge().apis,
+                groupFile: {
+                    ...mockBridge().apis.groupFile,
+                    getPrivateUrl,
+                    upload,
+                },
+            },
+            recallUploadedFile: vi.fn((id: string) => {
+                if (id === 'pfid-cached') {
+                    return {
+                        fileId: 'pfid-cached',
+                        scope: 'private' as const,
+                        userId: 67890,
+                        fileName: 'cached.txt',
+                        fileSize: 5,
+                        fileMd5: new Uint8Array(16),
+                        fileSha1: new Uint8Array(20),
+                        fileHash: 'cached-hash',
+                        rememberedAt: 0,
+                    };
+                }
+
+                if (id === 'gfid-reuploaded') {
+                    return {
+                        fileId: 'gfid-reuploaded',
+                        scope: 'group' as const,
+                        groupId: 12345,
+                        fileName: 'cached.txt',
+                        fileSize: 5,
+                        fileMd5: new Uint8Array(16),
+                        fileSha1: new Uint8Array(20),
+                        rememberedAt: 1,
+                    };
+                }
+
+                return undefined;
+            }),
+        });
+
+        await new ForwardApi(bridge as any).upload(
+            [
+                {
+                    userUin: 10001,
+                    nickname: 'alice',
+                    elements: [{ type: 'file', fileId: 'pfid-cached' } as any],
+                },
+            ],
+            12345,
+        );
+
+        expect(getPrivateUrl).toHaveBeenCalledWith(67890, 'pfid-cached', 'cached-hash');
+        expect(upload).toHaveBeenCalledWith(
+            12345,
+            'https://download.test/private-file',
+            'cached.txt',
+            '/',
+            true,
+            false,
+            { allowTemporary: true },
+        );
+        const [elements] = buildSendElemsMock.mock.calls[0]!;
+        expect(elements).toEqual([
+            expect.objectContaining({
+                type: 'file',
+                fileId: 'gfid-reuploaded',
+                fileName: 'cached.txt',
+                fileSize: 5,
+            }),
+        ]);
+    });
+});