@ihazz/bitrix24 1.0.3 → 1.1.1

package/tests/channel.test.ts

@@ -4,12 +4,14 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
   __setGatewayStateForTests,
   buildBotCodeCandidates,
+  buildConversationSessionKey,
   canCoalesceDirectMessage,
   convertButtonsToKeyboard,
   extractKeyboardFromPayload,
   handleWebhookRequest,
   mergeBufferedDirectMessages,
   mergeForwardedMessageContext,
+  resolveConversationRef,
   resolveDirectMessageCoalesceDelay,
   shouldSkipJoinChatWelcome,
   bitrix24Plugin,
@@ -72,6 +74,19 @@ describe('convertButtonsToKeyboard', () => {
     }
   });
 
+  it('converts a registered command without leading slash', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Help', callback_data: 'help' }],
+    ]);
+
+    const btn = kb[0];
+    expect(isButton(btn)).toBe(true);
+    if (isButton(btn)) {
+      expect(btn.COMMAND).toBe('help');
+      expect(btn.COMMAND_PARAMS).toBeUndefined();
+    }
+  });
+
   it('converts slash command with params', () => {
     const kb = convertButtonsToKeyboard([
       [{ text: 'Set Model', callback_data: '/model gpt-4o' }],
@@ -85,6 +100,18 @@ describe('convertButtonsToKeyboard', () => {
     }
   });
 
+  it('converts a registered command with params without leading slash', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Set Model', callback_data: 'model gpt-4o' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.COMMAND).toBe('model');
+      expect(btn.COMMAND_PARAMS).toBe('gpt-4o');
+    }
+  });
+
   it('converts slash command with multiple params', () => {
     const kb = convertButtonsToKeyboard([
       [{ text: 'Think', callback_data: '/think high extra' }],
@@ -359,14 +386,16 @@ describe('direct message coalescing helpers', () => {
         ...baseMsgCtx,
         messageId: '103',
         text: 'Forwarded body',
+        replyToMessageId: '77',
         media: [{ id: '1', name: 'photo.jpg', extension: '', size: 42, type: 'file' }],
         isForwarded: true,
       },
     );
 
-    expect(merged.text).toBe('hello\n\n[Forwarded message]\nForwarded body');
+    expect(merged.text).toBe('[User question about the forwarded message]\n\nhello\n\n[/User question]\n\nForwarded body');
     expect(merged.messageId).toBe('103');
     expect(merged.media).toHaveLength(1);
+    expect(merged.replyToMessageId).toBeUndefined();
     expect(merged.isForwarded).toBe(false);
   });
 
@@ -393,6 +422,45 @@ describe('direct message coalescing helpers', () => {
   });
 });
 
+describe('conversation helpers', () => {
+  it('uses direct dialog id as the stable conversation identity', () => {
+    const conversation = resolveConversationRef({
+      accountId: 'default',
+      dialogId: '2386',
+      isDirect: true,
+    });
+
+    expect(conversation.dialogId).toBe('2386');
+    expect(conversation.address).toBe('bitrix24:2386');
+    expect(conversation.historyKey).toBe('default:2386');
+    expect(conversation.peer).toEqual({ kind: 'direct', id: '2386' });
+  });
+
+  it('uses group dialog id as the stable conversation identity', () => {
+    const conversation = resolveConversationRef({
+      accountId: 'default',
+      dialogId: 'chat520',
+      isDirect: false,
+    });
+
+    expect(conversation.dialogId).toBe('chat520');
+    expect(conversation.address).toBe('bitrix24:chat520');
+    expect(conversation.historyKey).toBe('default:chat520');
+    expect(conversation.peer).toEqual({ kind: 'group', id: 'chat520' });
+  });
+
+  it('builds session keys from the stable conversation address', () => {
+    const conversation = resolveConversationRef({
+      accountId: 'default',
+      dialogId: '2386',
+      isDirect: true,
+    });
+
+    expect(buildConversationSessionKey('route:session', conversation))
+      .toBe('route:session:bitrix24:2386');
+  });
+});
+
 describe('join chat helpers', () => {
   it('does not skip unsupported group chats even in webhookUser mode', () => {
     expect(shouldSkipJoinChatWelcome({
@@ -554,7 +622,7 @@ describe('bitrix24Plugin', () => {
     });
 
     it('declares capabilities', () => {
-      expect(bitrix24Plugin.capabilities.chatTypes).toEqual(['direct']);
+      expect(bitrix24Plugin.capabilities.chatTypes).toEqual(['direct', 'group']);
       expect(bitrix24Plugin.capabilities.media).toBe(true);
       expect(bitrix24Plugin.capabilities.reactions).toBe(true);
       expect(bitrix24Plugin.capabilities.threads).toBe(false);
@@ -574,6 +642,24 @@ describe('bitrix24Plugin', () => {
       expect(result.approveHint).toContain('openclaw pairing approve bitrix24');
     });
 
+    it('resolveDmPolicy returns allowlist policy when configured', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({
+        account: { config: { dmPolicy: 'allowlist', allowFrom: ['bitrix24:42'] } },
+      });
+
+      expect(result.policy).toBe('allowlist');
+      expect(result.allowFrom).toEqual(['42']);
+    });
+
+    it('resolveDmPolicy returns open policy when configured', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({
+        account: { config: { dmPolicy: 'open' } },
+      });
+
+      expect(result.policy).toBe('open');
+      expect(result.allowFrom).toEqual([]);
+    });
+
     it('resolveDmPolicy defaults to webhookUser', () => {
       const result = bitrix24Plugin.security.resolveDmPolicy({});
       expect(result.policy).toBe('webhookUser');

package/tests/config.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { getConfig, isConfigured, listAccountIds, resolveAccount } from '../src/config.js';
+import { Bitrix24ConfigSchema } from '../src/config-schema.js';
 
 const mockCfg = {
   channels: {
@@ -24,6 +25,7 @@ describe('getConfig', () => {
     const cfg = getConfig(mockCfg);
     expect(cfg.webhookUrl).toBe('https://test.bitrix24.com/rest/1/abc123/');
     expect(cfg.botName).toBe('TestBot');
+    expect(cfg.dmPolicy).toBe('pairing');
     expect(cfg.allowFrom).toEqual(['bitrix24:1']);
   });
 
@@ -43,6 +45,41 @@ describe('getConfig', () => {
     const cfg = getConfig(mockCfg, 'nonexistent');
     expect(cfg.webhookUrl).toBe('https://test.bitrix24.com/rest/1/abc123/');
   });
+
+  it('keeps group-related config fields intact', () => {
+    const cfg = getConfig({
+      channels: {
+        bitrix24: {
+          webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
+          groupPolicy: 'webhookUser',
+          groupAllowFrom: ['chat208', '615'],
+          requireMention: true,
+          historyLimit: 100,
+          groups: {
+            '*': { requireMention: true },
+            chat208: {
+              groupPolicy: 'open',
+              requireMention: false,
+              watch: [{ userId: '77', topics: ['секрет'] }],
+            },
+          },
+        },
+      },
+    });
+
+    expect(cfg.groupPolicy).toBe('webhookUser');
+    expect(cfg.groupAllowFrom).toEqual(['chat208', '615']);
+    expect(cfg.requireMention).toBe(true);
+    expect(cfg.historyLimit).toBe(100);
+    expect(cfg.groups).toEqual({
+      '*': { requireMention: true },
+      chat208: {
+        groupPolicy: 'open',
+        requireMention: false,
+        watch: [{ userId: '77', topics: ['секрет'] }],
+      },
+    });
+  });
 });
 
 describe('isConfigured', () => {
@@ -87,4 +124,87 @@ describe('resolveAccount', () => {
     const acct = resolveAccount({}, 'missing');
     expect(acct.configured).toBe(false);
   });
+
+  it('accepts new group policy fields in account config', () => {
+    const acct = resolveAccount({
+      channels: {
+        bitrix24: {
+          webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
+          dmPolicy: 'allowlist',
+          groupPolicy: 'pairing',
+          groupAllowFrom: ['chat208'],
+          requireMention: false,
+          historyLimit: 50,
+          groups: {
+            '208': { groupPolicy: 'open' },
+          },
+        },
+      },
+    });
+
+    expect(acct.configured).toBe(true);
+    expect(acct.config.groupPolicy).toBe('pairing');
+    expect(acct.config.groupAllowFrom).toEqual(['chat208']);
+    expect(acct.config.requireMention).toBe(false);
+    expect(acct.config.historyLimit).toBe(50);
+    expect(acct.config.groups).toEqual({
+      '208': { groupPolicy: 'open', requireMention: true },
+    });
+  });
+
+  it('accepts agent mode watch rules in account config', () => {
+    const acct = resolveAccount({
+      channels: {
+        bitrix24: {
+          webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
+          agentMode: true,
+          agentWatch: {
+            '*': [
+              { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+            ],
+            '77': [
+              { userId: '*', topics: ['срочно'] },
+            ],
+          },
+        },
+      },
+    });
+
+    expect(acct.configured).toBe(true);
+    expect(acct.config.agentMode).toBe(true);
+    expect(acct.config.agentWatch).toEqual({
+      '*': [
+        { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+      ],
+      '77': [
+        { userId: '*', topics: ['срочно'] },
+      ],
+    });
+  });
+
+  it('rejects invalid group policy values', () => {
+    expect(() => resolveAccount({
+      channels: {
+        bitrix24: {
+          webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
+          groupPolicy: 'invalid',
+        },
+      },
+    } as unknown as Record<string, unknown>)).toThrow('Invalid config');
+  });
+});
+
+describe('Bitrix24ConfigSchema', () => {
+  it('applies defaults for new access and history options', () => {
+    const parsed = Bitrix24ConfigSchema.parse({
+      webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
+    });
+
+    expect(parsed.dmPolicy).toBe('webhookUser');
+    expect(parsed.groupPolicy).toBe('webhookUser');
+    expect(parsed.agentMode).toBe(false);
+    expect(parsed.requireMention).toBe(true);
+    expect(parsed.historyLimit).toBe(100);
+    expect(parsed.showTyping).toBe(true);
+  });
 });

package/tests/group-access.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  buildGroupMatchKeys,
+  checkGroupAccessPassive,
+  checkGroupAccessWithPairing,
+  normalizeGroupAllowList,
+  normalizeGroupEntry,
+  resolveGroupAccess,
+} from '../src/group-access.js';
+import type { PluginRuntime, ChannelPairingAdapter } from '../src/runtime.js';
+
+function makeMockRuntime(storeAllowFrom: string[] = []): PluginRuntime {
+  return {
+    config: { loadConfig: () => ({}) },
+    channel: {
+      routing: { resolveAgentRoute: vi.fn() },
+      reply: {
+        finalizeInboundContext: vi.fn(),
+        dispatchReplyWithBufferedBlockDispatcher: vi.fn(),
+      },
+      session: { recordInboundSession: vi.fn() },
+      pairing: {
+        readAllowFromStore: vi.fn().mockResolvedValue(storeAllowFrom),
+        upsertPairingRequest: vi.fn().mockResolvedValue({ code: 'ABCD1234', created: true }),
+        buildPairingReply: vi.fn(),
+      },
+    },
+    logging: { getChildLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }) },
+  } as unknown as PluginRuntime;
+}
+
+const mockAdapter: ChannelPairingAdapter = {
+  idLabel: 'bitrix24UserId',
+  normalizeAllowEntry: (entry) => entry,
+};
+
+describe('group-access helpers', () => {
+  it('normalizes numeric and dialog group ids', () => {
+    expect(normalizeGroupEntry(' 208 ')).toBe('208');
+    expect(normalizeGroupEntry(' Chat208 ')).toBe('chat208');
+  });
+
+  it('normalizes and deduplicates group allowlist entries', () => {
+    expect(normalizeGroupAllowList(['208', 'chat208', '208'])).toEqual(['208', 'chat208']);
+  });
+
+  it('builds group match keys from dialogId and chatId', () => {
+    expect(buildGroupMatchKeys({ dialogId: 'chat208', chatId: '208' })).toEqual(['chat208', '208']);
+  });
+});
+
+describe('resolveGroupAccess', () => {
+  it('defaults to webhookUser and mention-required groups', () => {
+    expect(resolveGroupAccess({
+      config: {},
+      dialogId: 'chat208',
+      chatId: '208',
+    })).toMatchObject({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groupAllowed: true,
+      senderAllowFrom: [],
+      watch: [],
+    });
+  });
+
+  it('matches explicit group config before wildcard', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groupPolicy: 'webhookUser',
+        groups: {
+          '*': { requireMention: true },
+          chat208: { groupPolicy: 'open', requireMention: false, allowFrom: ['42'] },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.groupPolicy).toBe('open');
+    expect(result.requireMention).toBe(false);
+    expect(result.senderAllowFrom).toEqual(['42']);
+    expect(result.matchedGroupKey).toBe('chat208');
+  });
+
+  it('resolves watch rules from matched group config', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groups: {
+          chat208: {
+            watch: [
+              { userId: 'bitrix24:77', topics: ['секрет', 'важно'], mode: 'notifyOwnerDm' },
+            ],
+          },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.watch).toEqual([
+      { userId: '77', topics: ['секрет', 'важно'], mode: 'notifyOwnerDm' },
+    ]);
+  });
+
+  it('preserves wildcard watch sender ids for any-user matching', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groups: {
+          chat208: {
+            watch: [
+              { userId: '*', topics: ['авария'] },
+            ],
+          },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.watch).toEqual([
+      { userId: '*', topics: ['авария'], mode: 'reply' },
+    ]);
+  });
+
+  it('merges explicit group watch rules before wildcard watch rules', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groups: {
+          '*': {
+            watch: [
+              { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+            ],
+          },
+          chat208: {
+            watch: [
+              { userId: '77', topics: ['секрет'] },
+            ],
+          },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.watch).toEqual([
+      { userId: '77', topics: ['секрет'], mode: 'reply' },
+      { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+    ]);
+  });
+
+  it('matches numeric chat id after dialog id lookup misses', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groups: {
+          '208': { groupPolicy: 'open', requireMention: false },
+          '*': { groupPolicy: 'webhookUser', requireMention: true },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.groupPolicy).toBe('open');
+    expect(result.requireMention).toBe(false);
+    expect(result.matchedGroupKey).toBe('208');
+  });
+
+  it('falls back to wildcard group config when no exact match exists', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groups: {
+          '*': { groupPolicy: 'allowlist', requireMention: false, allowFrom: ['42'] },
+        },
+      },
+      dialogId: 'chat615',
+      chatId: '615',
+    });
+
+    expect(result.groupPolicy).toBe('allowlist');
+    expect(result.requireMention).toBe(false);
+    expect(result.senderAllowFrom).toEqual(['42']);
+    expect(result.matchedGroupKey).toBe('*');
+  });
+
+  it('treats explicit group override as allowed even when top-level group allowlist is present', () => {
+    const result = resolveGroupAccess({
+      config: {
+        groupAllowFrom: ['chat300'],
+        groups: {
+          chat208: { groupPolicy: 'open' },
+        },
+      },
+      dialogId: 'chat208',
+      chatId: '208',
+    });
+
+    expect(result.groupAllowed).toBe(true);
+  });
+});
+
+describe('checkGroupAccessWithPairing', () => {
+  it('reports pairing passively without creating a request', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessPassive({
+      senderId: '99',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: { groupPolicy: 'pairing' },
+      runtime,
+      accountId: 'default',
+    });
+
+    expect(result).toBe('pairing');
+    expect(runtime.channel.pairing.upsertPairingRequest).not.toHaveBeenCalled();
+  });
+
+  it('allows any sender in open mode', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessWithPairing({
+      senderId: '77',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: { groupPolicy: 'open' },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(result).toBe('allow');
+  });
+
+  it('allows only webhook owner in webhookUser mode', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessWithPairing({
+      senderId: '42',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: {
+        groupPolicy: 'webhookUser',
+        webhookUrl: 'https://test.bitrix24.com/rest/42/token/',
+      },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(result).toBe('allow');
+  });
+
+  it('uses merged top-level and per-group allowFrom in allowlist mode', async () => {
+    const runtime = makeMockRuntime();
+    const allowed = await checkGroupAccessWithPairing({
+      senderId: '42',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: {
+        groupPolicy: 'allowlist',
+        allowFrom: ['7'],
+        groups: {
+          chat208: { allowFrom: ['42'] },
+        },
+      },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    const denied = await checkGroupAccessWithPairing({
+      senderId: '99',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: {
+        groupPolicy: 'allowlist',
+        allowFrom: ['7'],
+        groups: {
+          chat208: { allowFrom: ['42'] },
+        },
+      },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(allowed).toBe('allow');
+    expect(denied).toBe('deny');
+  });
+
+  it('creates pairing request for unknown sender in group pairing mode', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessWithPairing({
+      senderId: '99',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: { groupPolicy: 'pairing' },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(result).toBe('pairing');
+    expect(runtime.channel.pairing.upsertPairingRequest).toHaveBeenCalled();
+  });
+
+  it('denies groups outside configured group allowlist', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessWithPairing({
+      senderId: '42',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: {
+        groupPolicy: 'open',
+        groupAllowFrom: ['chat300'],
+      },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(result).toBe('deny');
+  });
+
+  it('allows groups listed by numeric chat id in top-level group allowlist', async () => {
+    const runtime = makeMockRuntime();
+    const result = await checkGroupAccessWithPairing({
+      senderId: '42',
+      dialogId: 'chat208',
+      chatId: '208',
+      config: {
+        groupPolicy: 'open',
+        groupAllowFrom: ['208'],
+      },
+      runtime,
+      accountId: 'default',
+      pairingAdapter: mockAdapter,
+    });
+
+    expect(result).toBe('allow');
+  });
+});