@ihazz/bitrix24 0.2.4 → 1.0.0

package/tests/inbound-handler.test.ts

@@ -1,12 +1,7 @@
+import { stringify as stringifyQueryString } from 'qs';
 import { describe, it, expect, vi, afterEach } from 'vitest';
-import { InboundHandler, normalizeMessageEvent } from '../src/inbound-handler.js';
-import type { B24MessageEvent, B24MsgContext, B24BotEntry } from '../src/types.js';
-
-// Import fixtures
-import textFixture from './fixtures/onimbotmessageadd-text.json';
-import fileFixture from './fixtures/onimbotmessageadd-file.json';
-import joinFixture from './fixtures/onimbotjoinchat.json';
-import commandFixture from './fixtures/onimcommandadd.json';
+import { InboundHandler } from '../src/inbound-handler.js';
+import type { B24MsgContext, FetchContext } from '../src/types.js';
 
 const silentLogger = {
   info: () => {},
@@ -15,6 +10,91 @@ const silentLogger = {
   debug: () => {},
 };
 
+const fetchCtx: FetchContext = {
+  webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+  botId: 2081,
+  botToken: 'bot_token_test_abc123',
+};
+
+const baseBot = {
+  id: 2081,
+  code: 'openclaw',
+  type: 'bot',
+  isHidden: false,
+  isSupportOpenline: false,
+  isReactionsEnabled: true,
+  backgroundId: null,
+  language: 'ru',
+  eventMode: 'fetch',
+};
+
+const baseUser = {
+  id: 1,
+  active: true,
+  name: 'Test User',
+  firstName: 'Test',
+  lastName: 'User',
+  workPosition: 'Developer',
+  color: '#df532d',
+  avatar: '',
+  gender: 'M',
+  birthday: '',
+  extranet: false,
+  bot: false,
+  connector: false,
+  externalAuthId: 'default',
+  status: 'online',
+  idle: false,
+  lastActivityDate: false,
+  absent: false,
+  departments: [1],
+  phones: false,
+  type: 'employee',
+};
+
+function createFetchMessageEvent(overrides: Record<string, unknown> = {}) {
+  return {
+    eventId: 1001,
+    type: 'ONIMBOTV2MESSAGEADD',
+    date: '2026-03-18T08:00:00+02:00',
+    data: {
+      bot: baseBot,
+      message: {
+        id: 490659,
+        chatId: 40985,
+        authorId: 1,
+        date: '2026-03-18T08:00:00+02:00',
+        text: 'Hello, how are you?',
+        isSystem: false,
+        uuid: '',
+        forward: null,
+        params: {},
+        viewedByOthers: false,
+      },
+      chat: {
+        id: 40985,
+        dialogId: '1',
+        type: 'private',
+        name: 'Test User',
+        entityType: '',
+        owner: 1,
+        avatar: '',
+        color: '#ab7761',
+      },
+      user: baseUser,
+      language: 'ru',
+      ...overrides,
+    },
+  };
+}
+
+function createWebhookEvent(eventType: string, data: Record<string, unknown>) {
+  return {
+    event: eventType,
+    data,
+  };
+}
+
 describe('InboundHandler', () => {
   let handler: InboundHandler;
 
@@ -22,15 +102,15 @@ describe('InboundHandler', () => {
     handler?.destroy();
   });
 
-  it('dispatches text message events', async () => {
+  it('dispatches fetch message events', async () => {
     const onMessage = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { dmPolicy: 'pairing' },
       logger: silentLogger,
       onMessage,
     });
 
-    const result = await handler.handleWebhook(textFixture);
+    const result = await handler.handleFetchEvent(createFetchMessageEvent(), fetchCtx);
     expect(result).toBe(true);
     expect(onMessage).toHaveBeenCalledOnce();
 
@@ -39,125 +119,530 @@ describe('InboundHandler', () => {
     expect(ctx.text).toBe('Hello, how are you?');
     expect(ctx.senderId).toBe('1');
     expect(ctx.senderName).toBe('Test User');
+    expect(ctx.senderFirstName).toBe('Test');
     expect(ctx.chatId).toBe('1');
+    expect(ctx.chatInternalId).toBe('40985');
+    expect(ctx.messageId).toBe('490659');
+    expect(ctx.replyToMessageId).toBeUndefined();
+    expect(ctx.isForwarded).toBe(false);
     expect(ctx.isDm).toBe(true);
     expect(ctx.isGroup).toBe(false);
-    expect(ctx.botToken).toBe('bot_token_test_abc123');
-    expect(ctx.userToken).toBe('user_token_test_def456');
+    expect(ctx.media).toEqual([]);
+    expect(ctx.language).toBe('ru');
+    expect(ctx.botId).toBe(2081);
+  });
+
+  it('keeps incoming dialogId for direct chats without replacing it by user id', async () => {
+    const onMessage = vi.fn();
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+      onMessage,
+    });
+
+    const event = createFetchMessageEvent({
+      chat: {
+        id: 40985,
+        dialogId: '123',
+        type: 'private',
+        name: 'Test User',
+        entityType: '',
+        owner: 55,
+        avatar: '',
+        color: '#ab7761',
+      },
+      user: {
+        ...baseUser,
+        id: 55,
+      },
+    });
+
+    await handler.handleFetchEvent(event, fetchCtx);
+
+    const ctx = onMessage.mock.calls[0][0] as B24MsgContext;
+    expect(ctx.chatId).toBe('123');
+    expect(ctx.senderId).toBe('55');
+  });
+
+  it('deduplicates fetch messages by message id', async () => {
+    const onMessage = vi.fn();
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+      onMessage,
+    });
+
+    const event = createFetchMessageEvent();
+    await handler.handleFetchEvent(event, fetchCtx);
+    await handler.handleFetchEvent(event, fetchCtx);
+
+    expect(onMessage).toHaveBeenCalledOnce();
+  });
+
+  it('extracts media ids from V2 message params', async () => {
+    const onMessage = vi.fn();
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+      onMessage,
+    });
+
+    const event = createFetchMessageEvent({
+      message: {
+        id: 492035,
+        chatId: 40985,
+        authorId: 1,
+        date: '2026-03-18T08:00:00+02:00',
+        text: '',
+        isSystem: false,
+        uuid: '',
+        forward: null,
+        params: { FILE_ID: [94611, '94612'] },
+        viewedByOthers: false,
+      },
+    });
+
+    await handler.handleFetchEvent(event, fetchCtx);
+
+    const ctx = onMessage.mock.calls[0][0] as B24MsgContext;
+    expect(ctx.media).toEqual([
+      {
+        id: '94611',
+        name: 'file_94611',
+        extension: '',
+        size: 0,
+        type: 'file',
+      },
+      {
+        id: '94612',
+        name: 'file_94612',
+        extension: '',
+        size: 0,
+        type: 'file',
+      },
+    ]);
+  });
+
+  it('extracts reply target id from V2 message params', async () => {
+    const onMessage = vi.fn();
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+      onMessage,
+    });
+
+    const event = createFetchMessageEvent({
+      message: {
+        id: 492036,
+        chatId: 40985,
+        authorId: 1,
+        date: '2026-03-18T08:00:00+02:00',
+        text: 'reply text',
+        isSystem: false,
+        uuid: '',
+        forward: null,
+        params: { REPLY_ID: '490600' },
+        viewedByOthers: false,
+      },
+    });
+
+    await handler.handleFetchEvent(event, fetchCtx);
+
+    const ctx = onMessage.mock.calls[0][0] as B24MsgContext;
+    expect(ctx.replyToMessageId).toBe('490600');
+  });
+
+  it('marks forwarded V2 messages', async () => {
+    const onMessage = vi.fn();
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+      onMessage,
+    });
+
+    const event = createFetchMessageEvent({
+      message: {
+        id: 492037,
+        chatId: 40985,
+        authorId: 1,
+        date: '2026-03-18T08:00:00+02:00',
+        text: 'forwarded body',
+        isSystem: false,
+        uuid: '',
+        forward: { id: 'chat208/6717', userId: 1, chatType: 'chat' },
+        params: {},
+        viewedByOthers: false,
+      },
+    });
+
+    await handler.handleFetchEvent(event, fetchCtx);
+
+    const ctx = onMessage.mock.calls[0][0] as B24MsgContext;
+    expect(ctx.isForwarded).toBe(true);
   });
 
-  it('deduplicates messages', async () => {
+  it('dispatches webhook message events from JSON body', async () => {
     const onMessage = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { webhookUrl: fetchCtx.webhookUrl, botToken: fetchCtx.botToken, dmPolicy: 'pairing' },
       logger: silentLogger,
       onMessage,
     });
 
-    await handler.handleWebhook(textFixture);
-    await handler.handleWebhook(textFixture);
+    const payload = createWebhookEvent('ONIMBOTV2MESSAGEADD', {
+      bot: {
+        id: '2081',
+        code: 'openclaw',
+        auth: {
+          access_token: 'bot_token_test_abc123',
+          refresh_token: 'refresh_token_test',
+        },
+      },
+      message: {
+        id: '490659',
+        chatId: '40985',
+        authorId: '1',
+        date: '2026-03-18T08:00:00+02:00',
+        text: 'Hello from webhook',
+        isSystem: '0',
+        uuid: '',
+        forward: '',
+        params: {},
+        viewedByOthers: '0',
+      },
+      chat: {
+        id: '40985',
+        dialogId: '1',
+        type: 'private',
+        name: 'Test User',
+        entityType: '',
+        owner: '1',
+        avatar: '',
+        color: '#ab7761',
+      },
+      user: {
+        ...baseUser,
+        id: '1',
+        active: '1',
+        extranet: '0',
+        bot: '0',
+        connector: '0',
+        idle: '0',
+        lastActivityDate: '0',
+        absent: '0',
+        departments: ['1'],
+        phones: '0',
+      },
+      language: 'ru',
+    });
 
+    const result = await handler.handleWebhook(JSON.stringify(payload));
+    expect(result).toBe(true);
     expect(onMessage).toHaveBeenCalledOnce();
+
+    const ctx = onMessage.mock.calls[0][0] as B24MsgContext;
+    expect(ctx.text).toBe('Hello from webhook');
+    expect(ctx.chatId).toBe('1');
+    expect(ctx.messageId).toBe('490659');
   });
 
-  it('dispatches all messages (access control handled externally)', async () => {
+  it('dispatches webhook message events from query string body', async () => {
     const onMessage = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'allowlist', allowFrom: ['99'] },
+      config: { webhookUrl: fetchCtx.webhookUrl, botToken: fetchCtx.botToken, dmPolicy: 'pairing' },
       logger: silentLogger,
       onMessage,
     });
 
-    await handler.handleWebhook(textFixture);
-    // Access control is now handled in channel.ts onMessage callback, not in InboundHandler
+    const payload = createWebhookEvent('ONIMBOTV2MESSAGEADD', {
+      bot: {
+        id: '2081',
+        code: 'openclaw',
+        auth: {
+          access_token: 'bot_token_test_abc123',
+          refresh_token: 'refresh_token_test',
+        },
+      },
+      message: {
+        id: '490660',
+        chatId: '40985',
+        authorId: '1',
+        date: '2026-03-18T08:00:00+02:00',
+        text: 'Hello from qs',
+        isSystem: '0',
+        uuid: '',
+        forward: '',
+        params: {},
+        viewedByOthers: '0',
+      },
+      chat: {
+        id: '40985',
+        dialogId: '1',
+        type: 'private',
+        name: 'Test User',
+        entityType: '',
+        owner: '1',
+        avatar: '',
+        color: '#ab7761',
+      },
+      user: {
+        ...baseUser,
+        id: '1',
+        active: '1',
+        extranet: '0',
+        bot: '0',
+        connector: '0',
+        idle: '0',
+        lastActivityDate: '0',
+        absent: '0',
+        departments: ['1'],
+        phones: '0',
+      },
+      language: 'ru',
+    });
+
+    const result = await handler.handleWebhook(stringifyQueryString(payload));
+    expect(result).toBe(true);
     expect(onMessage).toHaveBeenCalledOnce();
   });
 
   it('dispatches join chat events', async () => {
     const onJoinChat = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { dmPolicy: 'pairing' },
       logger: silentLogger,
       onJoinChat,
     });
 
-    const result = await handler.handleWebhook(joinFixture);
+    const event = {
+      eventId: 1002,
+      type: 'ONIMBOTV2JOINCHAT',
+      date: '2026-03-18T08:00:00+02:00',
+      data: {
+        bot: baseBot,
+        dialogId: '1',
+        chat: {
+          id: 40985,
+          dialogId: '1',
+          type: 'private',
+          name: 'Test User',
+          entityType: '',
+          owner: 1,
+          avatar: '',
+          color: '#ab7761',
+        },
+        user: baseUser,
+        language: 'ru',
+      },
+    };
+
+    const result = await handler.handleFetchEvent(event, fetchCtx);
     expect(result).toBe(true);
     expect(onJoinChat).toHaveBeenCalledOnce();
+    expect(onJoinChat).toHaveBeenCalledWith({
+      dialogId: '1',
+      chatType: 'private',
+      language: 'ru',
+      fetchCtx,
+    });
   });
 
   it('dispatches command events', async () => {
     const onCommand = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { dmPolicy: 'pairing' },
       logger: silentLogger,
       onCommand,
     });
 
-    const result = await handler.handleWebhook(commandFixture);
+    const event = {
+      eventId: 1003,
+      type: 'ONIMBOTV2COMMANDADD',
+      date: '2026-03-18T08:00:00+02:00',
+      data: {
+        bot: baseBot,
+        command: {
+          id: 53,
+          command: '/help',
+          params: 'topic',
+          context: 'textarea',
+        },
+        message: {
+          id: 490667,
+          chatId: 40985,
+          authorId: 1,
+          date: '2026-03-18T08:00:00+02:00',
+          text: '/help topic',
+          isSystem: false,
+          uuid: '',
+          forward: null,
+          params: {},
+          viewedByOthers: false,
+        },
+        chat: {
+          id: 40985,
+          dialogId: '1',
+          type: 'private',
+          name: 'Test User',
+          entityType: '',
+          owner: 1,
+          avatar: '',
+          color: '#ab7761',
+        },
+        user: baseUser,
+        language: 'ru',
+      },
+    };
+
+    const result = await handler.handleFetchEvent(event, fetchCtx);
     expect(result).toBe(true);
     expect(onCommand).toHaveBeenCalledOnce();
+    expect(onCommand).toHaveBeenCalledWith({
+      commandId: 53,
+      commandName: 'help',
+      commandParams: 'topic',
+      commandText: '/help topic',
+      senderId: '1',
+      dialogId: '1',
+      chatType: 'P',
+      messageId: '490667',
+      language: 'ru',
+      fetchCtx,
+    });
   });
 
-  it('returns false for unknown event types', async () => {
+  it('dispatches keyboard command events even when message payload is incomplete', async () => {
+    const onCommand = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { dmPolicy: 'pairing' },
       logger: silentLogger,
+      onCommand,
     });
 
-    const result = await handler.handleWebhook({ event: 'UNKNOWN_EVENT' });
-    expect(result).toBe(false);
+    const event = {
+      eventId: 1004,
+      type: 'ONIMBOTV2COMMANDADD',
+      date: '2026-03-18T08:00:00+02:00',
+      data: {
+        bot: baseBot,
+        command: {
+          id: 54,
+          command: '/status',
+          context: 'keyboard',
+        },
+        chat: {
+          id: 40985,
+          dialogId: 1,
+          type: 'private',
+          name: 'Test User',
+          entityType: '',
+          owner: 1,
+          avatar: '',
+          color: '#ab7761',
+        },
+        user: baseUser,
+        language: 'ru',
+      },
+    };
+
+    const result = await handler.handleFetchEvent(event as never, fetchCtx);
+    expect(result).toBe(true);
+    expect(onCommand).toHaveBeenCalledOnce();
+    expect(onCommand).toHaveBeenCalledWith({
+      commandId: 54,
+      commandName: 'status',
+      commandParams: '',
+      commandText: '/status',
+      senderId: '1',
+      dialogId: '1',
+      chatType: 'P',
+      messageId: '1004',
+      language: 'ru',
+      fetchCtx,
+    });
   });
 
-  it('returns false for missing event type', async () => {
+  it('builds command text from command payload instead of message text', async () => {
+    const onCommand = vi.fn();
     handler = new InboundHandler({
-      config: { dmPolicy: 'open' },
+      config: { dmPolicy: 'pairing' },
       logger: silentLogger,
+      onCommand,
     });
 
-    const result = await handler.handleWebhook({});
-    expect(result).toBe(false);
+    const event = {
+      eventId: 1005,
+      type: 'ONIMBOTV2COMMANDADD',
+      date: '2026-03-18T08:00:00+02:00',
+      data: {
+        bot: baseBot,
+        command: {
+          id: 55,
+          command: '/status',
+          params: '',
+          context: 'keyboard',
+        },
+        message: {
+          id: 490668,
+          chatId: 40985,
+          authorId: 1,
+          date: '2026-03-18T08:00:00+02:00',
+          text: '/commands',
+          isSystem: false,
+          uuid: '',
+          forward: null,
+          params: {},
+          viewedByOthers: false,
+        },
+        chat: {
+          id: 40985,
+          dialogId: '1',
+          type: 'private',
+          name: 'Test User',
+          entityType: '',
+          owner: 1,
+          avatar: '',
+          color: '#ab7761',
+        },
+        user: baseUser,
+        language: 'ru',
+      },
+    };
+
+    const result = await handler.handleFetchEvent(event as never, fetchCtx);
+    expect(result).toBe(true);
+    expect(onCommand).toHaveBeenCalledOnce();
+    expect(onCommand).toHaveBeenCalledWith({
+      commandId: 55,
+      commandName: 'status',
+      commandParams: '',
+      commandText: '/status',
+      senderId: '1',
+      dialogId: '1',
+      chatType: 'P',
+      messageId: '490668',
+      language: 'ru',
+      fetchCtx,
+    });
   });
-});
 
-describe('normalizeMessageEvent', () => {
-  it('normalizes a text message event', () => {
-    const event = textFixture as unknown as B24MessageEvent;
-    const botEntry = Object.values(event.data.BOT)[0] as B24BotEntry;
-    const ctx = normalizeMessageEvent(event, botEntry);
+  it('returns true for unknown event types to acknowledge delivery', async () => {
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
+    });
 
-    expect(ctx.channel).toBe('bitrix24');
-    expect(ctx.senderId).toBe('1');
-    expect(ctx.senderName).toBe('Test User');
-    expect(ctx.senderFirstName).toBe('Test');
-    expect(ctx.chatId).toBe('1');
-    expect(ctx.chatInternalId).toBe('40985');
-    expect(ctx.messageId).toBe('490659');
-    expect(ctx.text).toBe('Hello, how are you?');
-    expect(ctx.isDm).toBe(true);
-    expect(ctx.isGroup).toBe(false);
-    expect(ctx.media).toEqual([]);
-    expect(ctx.platform).toBe('web');
-    expect(ctx.language).toBe('ru');
-    expect(ctx.botId).toBe(2081);
-    expect(ctx.memberId).toBe('test_member_id_123');
-    expect(ctx.clientEndpoint).toBe('https://test.bitrix24.com/rest/');
+    const result = await handler.handleWebhook({ event: 'UNKNOWN_EVENT', data: {} });
+    expect(result).toBe(true);
   });
 
-  it('normalizes a file message event', () => {
-    const event = fileFixture as unknown as B24MessageEvent;
-    const botEntry = Object.values(event.data.BOT)[0] as B24BotEntry;
-    const ctx = normalizeMessageEvent(event, botEntry);
-
-    expect(ctx.text).toBe('');
-    expect(ctx.media).toHaveLength(1);
-    expect(ctx.media[0]).toEqual({
-      id: '94611',
-      name: 'document.txt',
-      extension: 'txt',
-      size: 101,
-      type: 'file',
-      urlDownload: 'https://test.bitrix24.com/disk/downloadFile/94611/',
+  it('returns false for missing event type', async () => {
+    handler = new InboundHandler({
+      config: { dmPolicy: 'pairing' },
+      logger: silentLogger,
     });
+
+    const result = await handler.handleWebhook({});
+    expect(result).toBe(false);
   });
 });