@ihazz/bitrix24 1.0.3 → 1.1.1

package/src/types.ts

@@ -66,6 +66,8 @@ export interface B24V2User {
 }
 
 /** Message entity from V2 events */
+export type B24V2MessageParams = Record<string, unknown> | unknown[];
+
 export interface B24V2Message {
   id: number;
   chatId: number;
@@ -75,7 +77,7 @@ export interface B24V2Message {
   isSystem: boolean;
   uuid: string;
   forward: { id: number; userId: number; chatId: number; date: string } | null;
-  params: Record<string, unknown>;
+  params: B24V2MessageParams;
   viewedByOthers: boolean;
 }
 
@@ -131,6 +133,14 @@ export interface B24V2MessageEventData {
   language: string;
 }
 
+/** ONIMV2MESSAGEADD / ONIMV2MESSAGEUPDATE data */
+export interface B24V2UserMessageEventData {
+  message: B24V2Message;
+  chat: B24V2Chat;
+  user: B24V2User;
+  language: string;
+}
+
 /** ONIMBOTV2MESSAGEDELETE data */
 export interface B24V2MessageDeleteEventData {
   bot: B24V2Bot | B24V2WebhookBot;
@@ -178,6 +188,7 @@ export interface B24V2ReactionEventData {
 /** Union of V2 event data */
 export type B24V2EventData =
   | B24V2MessageEventData
+  | B24V2UserMessageEventData
   | B24V2MessageDeleteEventData
   | B24V2JoinChatEventData
   | B24V2CommandEventData
@@ -244,10 +255,24 @@ export interface B24V2BotListResult {
 
 /** Response from imbot.v2.Chat.Message.send */
 export interface B24V2SendMessageResult {
-  id: number;
+  id?: number | null;
   uuidMap: Record<string, number>;
 }
 
+/** Response from imbot.v2.Chat.Message.get */
+export interface B24V2GetMessageResult {
+  message: B24V2Message;
+  user: B24V2User;
+}
+
+/** Response from imbot.v2.Chat.Message.getContext */
+export interface B24V2GetMessageContextResult {
+  messages: B24V2Message[];
+  users: B24V2User[];
+  hasPrevPage: boolean;
+  hasNextPage: boolean;
+}
+
 /** Available status codes for imbot.v2.Chat.InputAction.notify */
 export type B24InputActionStatusCode =
   | 'IMBOT_AGENT_ACTION_THINKING'
@@ -337,6 +362,34 @@ export interface FetchContext {
 
 // ─── Plugin Config Types ─────────────────────────────────────────────────────
 
+export type Bitrix24DmPolicy = 'pairing' | 'webhookUser' | 'allowlist' | 'open';
+
+export type Bitrix24GroupPolicy =
+  | 'disabled'
+  | 'webhookUser'
+  | 'pairing'
+  | 'allowlist'
+  | 'open';
+
+export interface Bitrix24GroupWatchConfig {
+  userId: string;
+  topics?: string[];
+  mode?: 'reply' | 'notifyOwnerDm';
+}
+
+export interface Bitrix24AgentWatchConfig {
+  userId: string;
+  topics?: string[];
+  mode?: 'notifyOwnerDm';
+}
+
+export interface Bitrix24GroupConfig {
+  groupPolicy?: Bitrix24GroupPolicy;
+  requireMention?: boolean;
+  allowFrom?: string[];
+  watch?: Bitrix24GroupWatchConfig[];
+}
+
 export interface Bitrix24AccountConfig {
   enabled?: boolean;
   webhookUrl?: string;
@@ -350,7 +403,13 @@ export interface Bitrix24AccountConfig {
   agentMode?: boolean;
   pollingIntervalMs?: number;
   pollingFastIntervalMs?: number;
-  dmPolicy?: 'pairing' | 'webhookUser';
+  dmPolicy?: Bitrix24DmPolicy;
+  groupPolicy?: Bitrix24GroupPolicy;
+  groupAllowFrom?: string[];
+  requireMention?: boolean;
+  historyLimit?: number;
+  groups?: Record<string, Bitrix24GroupConfig>;
+  agentWatch?: Record<string, Bitrix24AgentWatchConfig[]>;
   showTyping?: boolean;
   streamUpdates?: boolean;
   updateIntervalMs?: number;
@@ -364,20 +423,25 @@ export interface Bitrix24PluginConfig extends Bitrix24AccountConfig {
 
 export interface B24MsgContext {
   channel: 'bitrix24';
+  eventScope?: 'bot' | 'user';
   senderId: string;
   senderName: string;
   senderFirstName?: string;
   chatId: string;
   chatInternalId: string;
+  chatName?: string;
+  chatType?: string;
   messageId: string;
   replyToMessageId?: string;
   isForwarded?: boolean;
+  wasMentioned?: boolean;
   text: string;
   isDm: boolean;
   isGroup: boolean;
   media: B24MediaItem[];
   platform?: string;
   language?: string;
+  timestamp?: number;
   raw: B24V2FetchEventItem | B24V2WebhookEvent;
   botId: number;
   memberId: string;

package/tests/access-control.test.ts

@@ -100,6 +100,16 @@ describe('checkAccess', () => {
   it('returns false for pairing mode without runtime state', () => {
     expect(checkAccess('1', { dmPolicy: 'pairing' })).toBe(false);
   });
+
+  it('allows any sender in open mode', () => {
+    expect(checkAccess('1', { dmPolicy: 'open' })).toBe(true);
+    expect(checkAccess('77', { dmPolicy: 'open' })).toBe(true);
+  });
+
+  it('allows only configured identities in allowlist mode', () => {
+    expect(checkAccess('42', { dmPolicy: 'allowlist', allowFrom: ['bitrix24:42'] })).toBe(true);
+    expect(checkAccess('77', { dmPolicy: 'allowlist', allowFrom: ['bitrix24:42'] })).toBe(false);
+  });
 });
 
 function makeMockRuntime(storeAllowFrom: string[] = []): PluginRuntime {
@@ -266,6 +276,39 @@ describe('checkAccessWithPairing', () => {
     expect(runtime.channel.pairing.upsertPairingRequest).not.toHaveBeenCalled();
   });
 
+  it('returns allow for any sender in open mode', async () => {
+    const runtime = makeMockRuntime();
+
+    const result = await checkAccessWithPairing({
+      senderId: '77',
+      config: { dmPolicy: 'open' },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+      sendReply: vi.fn(),
+      logger: silentLogger,
+    });
+
+    expect(result).toBe('allow');
+  });
+
+  it('returns deny for non-allowlisted sender in allowlist mode', async () => {
+    const runtime = makeMockRuntime();
+
+    const result = await checkAccessWithPairing({
+      senderId: '77',
+      config: { dmPolicy: 'allowlist', allowFrom: ['bitrix24:42'] },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+      sendReply: vi.fn(),
+      logger: silentLogger,
+    });
+
+    expect(result).toBe('deny');
+    expect(runtime.channel.pairing.upsertPairingRequest).not.toHaveBeenCalled();
+  });
+
   it('uses senderId as the pairing identity even when direct dialogId differs', async () => {
     const runtime = makeMockRuntime(['42']);
 

package/tests/api.test.ts

@@ -92,4 +92,135 @@ describe('Bitrix24Api', () => {
       code: 'INVALID_RESPONSE',
     });
   });
+
+  it('sends native forwards via forwardIds', async () => {
+    const api = new Bitrix24Api({ logger: silentLogger });
+    const callWebhookSpy = vi.spyOn(api, 'callWebhook').mockResolvedValueOnce({
+      result: { id: null, uuidMap: {} } as never,
+    });
+
+    await expect(api.sendMessage(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 7, botToken: 'bot_token' },
+      '42',
+      null,
+      { forwardMessages: [31304] },
+    )).resolves.toBe(0);
+
+    expect(callWebhookSpy).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      'imbot.v2.Chat.Message.send',
+      expect.objectContaining({
+        botId: 7,
+        botToken: 'bot_token',
+        dialogId: '42',
+        fields: expect.any(Object),
+      }),
+    );
+    const callParams = callWebhookSpy.mock.calls[0][2] as Record<string, unknown>;
+    const fields = callParams.fields as Record<string, unknown>;
+    expect(fields.forwardIds).toBeTypeOf('object');
+    expect(fields.forwardIds).not.toBeNull();
+    expect(Object.values(fields.forwardIds as Record<string, number>)).toEqual([31304]);
+    expect(Object.keys(fields.forwardIds as Record<string, number>)[0]).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    );
+  });
+
+  it('fetches a single message by id', async () => {
+    const api = new Bitrix24Api({ logger: silentLogger });
+    const callWebhookSpy = vi.spyOn(api, 'callWebhook').mockResolvedValueOnce({
+      result: {
+        message: { id: 789 },
+        user: { id: 1 },
+      } as never,
+    });
+
+    await expect(api.getMessage(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 7, botToken: 'bot_token' },
+      789,
+    )).resolves.toEqual({
+      message: { id: 789 },
+      user: { id: 1 },
+    });
+
+    expect(callWebhookSpy).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      'imbot.v2.Chat.Message.get',
+      {
+        botId: 7,
+        botToken: 'bot_token',
+        messageId: 789,
+      },
+    );
+  });
+
+  it('fetches message context window by id', async () => {
+    const api = new Bitrix24Api({ logger: silentLogger });
+    const callWebhookSpy = vi.spyOn(api, 'callWebhook').mockResolvedValueOnce({
+      result: {
+        messages: [],
+        users: [],
+        hasPrevPage: false,
+        hasNextPage: false,
+      } as never,
+    });
+
+    await expect(api.getMessageContext(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 7, botToken: 'bot_token' },
+      789,
+      5,
+    )).resolves.toEqual({
+      messages: [],
+      users: [],
+      hasPrevPage: false,
+      hasNextPage: false,
+    });
+
+    expect(callWebhookSpy).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      'imbot.v2.Chat.Message.getContext',
+      {
+        botId: 7,
+        botToken: 'bot_token',
+        messageId: 789,
+        range: 5,
+      },
+    );
+  });
+
+  it('fetches events with withUserEvents when agent mode is enabled', async () => {
+    const api = new Bitrix24Api({ logger: silentLogger });
+    const callWebhookSpy = vi.spyOn(api, 'callWebhook').mockResolvedValueOnce({
+      result: {
+        events: [],
+        lastEventId: 0,
+        hasMore: false,
+      } as never,
+    });
+
+    await expect(api.fetchEvents(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 7, botToken: 'bot_token' },
+      { offset: 100, limit: 50, withUserEvents: true },
+    )).resolves.toEqual({
+      events: [],
+      lastEventId: 0,
+      hasMore: false,
+    });
+
+    expect(callWebhookSpy).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      'imbot.v2.Event.get',
+      {
+        botId: 7,
+        botToken: 'bot_token',
+        offset: 100,
+        limit: 50,
+        withUserEvents: true,
+      },
+    );
+  });
 });