@ihazz/bitrix24 0.2.5 → 1.0.0

package/tests/channel.test.ts

@@ -2,9 +2,16 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Readable, PassThrough } from 'node:stream';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import {
+  __setGatewayStateForTests,
+  buildBotCodeCandidates,
+  canCoalesceDirectMessage,
   convertButtonsToKeyboard,
   extractKeyboardFromPayload,
   handleWebhookRequest,
+  mergeBufferedDirectMessages,
+  mergeForwardedMessageContext,
+  resolveDirectMessageCoalesceDelay,
+  shouldSkipJoinChatWelcome,
   bitrix24Plugin,
 } from '../src/channel.js';
 import type { KeyboardButton, KeyboardNewline, B24Keyboard } from '../src/types.js';
@@ -26,6 +33,26 @@ function isNewline(item: KeyboardButton | KeyboardNewline): item is KeyboardNewl
   return 'TYPE' in item && item.TYPE === 'NEWLINE';
 }
 
+describe('buildBotCodeCandidates', () => {
+  it('uses explicit botCode when it is configured', () => {
+    expect(buildBotCodeCandidates({
+      webhookUrl: 'https://test.bitrix24.com/rest/42/token/',
+      botCode: 'custom_bot',
+    }, 5)).toEqual(['custom_bot']);
+  });
+
+  it('builds automatic codes from webhook user id', () => {
+    expect(buildBotCodeCandidates({
+      webhookUrl: 'https://test.bitrix24.com/rest/42/token/',
+    }, 4)).toEqual([
+      'openclaw_42',
+      'openclaw_42_2',
+      'openclaw_42_3',
+      'openclaw_42_4',
+    ]);
+  });
+});
+
 // ─── convertButtonsToKeyboard ────────────────────────────────────────────────
 
 describe('convertButtonsToKeyboard', () => {
@@ -284,9 +311,124 @@ describe('extractKeyboardFromPayload', () => {
   });
 });
 
+describe('direct message coalescing helpers', () => {
+  const baseMsgCtx = {
+    channel: 'bitrix24' as const,
+    senderId: '1',
+    senderName: 'Test User',
+    senderFirstName: 'Test',
+    chatId: '1',
+    chatInternalId: '40985',
+    messageId: '100',
+    text: 'hello',
+    isDm: true,
+    isGroup: false,
+    media: [],
+    language: 'ru',
+    raw: { type: 'ONIMBOTV2MESSAGEADD' },
+    botId: 295,
+    memberId: '',
+  };
+
+  it('coalesces only plain direct text messages', () => {
+    expect(canCoalesceDirectMessage(baseMsgCtx, { dmPolicy: 'webhookUser' })).toBe(true);
+    expect(canCoalesceDirectMessage({ ...baseMsgCtx, text: '/status' }, { dmPolicy: 'webhookUser' })).toBe(false);
+    expect(canCoalesceDirectMessage({ ...baseMsgCtx, media: [{ id: '1', name: 'x', extension: '', size: 1, type: 'file' }] }, { dmPolicy: 'webhookUser' })).toBe(false);
+    expect(canCoalesceDirectMessage({ ...baseMsgCtx, replyToMessageId: '77' }, { dmPolicy: 'webhookUser' })).toBe(false);
+    expect(canCoalesceDirectMessage({ ...baseMsgCtx, isForwarded: true }, { dmPolicy: 'webhookUser' })).toBe(false);
+    expect(canCoalesceDirectMessage({ ...baseMsgCtx, isDm: false, isGroup: true }, { dmPolicy: 'webhookUser' })).toBe(false);
+    expect(canCoalesceDirectMessage(baseMsgCtx, { dmPolicy: 'pairing' })).toBe(false);
+  });
+
+  it('merges buffered direct messages with newline separators and last message id', () => {
+    const merged = mergeBufferedDirectMessages([
+      baseMsgCtx,
+      { ...baseMsgCtx, messageId: '101', text: 'second' },
+      { ...baseMsgCtx, messageId: '102', text: 'third', language: 'en' },
+    ]);
+
+    expect(merged.text).toBe('hello\nsecond\nthird');
+    expect(merged.messageId).toBe('102');
+    expect(merged.language).toBe('en');
+  });
+
+  it('merges a forwarded message with buffered question context', () => {
+    const merged = mergeForwardedMessageContext(
+      baseMsgCtx,
+      {
+        ...baseMsgCtx,
+        messageId: '103',
+        text: 'Forwarded body',
+        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.messageId).toBe('103');
+    expect(merged.media).toHaveLength(1);
+    expect(merged.isForwarded).toBe(false);
+  });
+
+  it('uses short debounce and extends the window until max wait', () => {
+    expect(resolveDirectMessageCoalesceDelay({
+      startedAt: 1000,
+      now: 1000,
+    })).toBe(200);
+
+    expect(resolveDirectMessageCoalesceDelay({
+      startedAt: 1000,
+      now: 1150,
+    })).toBe(200);
+
+    expect(resolveDirectMessageCoalesceDelay({
+      startedAt: 1000,
+      now: 5900,
+    })).toBe(100);
+
+    expect(resolveDirectMessageCoalesceDelay({
+      startedAt: 1000,
+      now: 6200,
+    })).toBe(0);
+  });
+});
+
+describe('join chat helpers', () => {
+  it('does not skip unsupported group chats even in webhookUser mode', () => {
+    expect(shouldSkipJoinChatWelcome({
+      dialogId: 'chat123',
+      chatType: 'chat',
+      webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+      dmPolicy: 'webhookUser',
+    })).toBe(false);
+  });
+
+  it('skips welcome for non-owner direct dialogs in webhookUser mode', () => {
+    expect(shouldSkipJoinChatWelcome({
+      dialogId: '42',
+      chatType: 'user',
+      webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+      dmPolicy: 'webhookUser',
+    })).toBe(true);
+  });
+
+  it('does not skip welcome for owner direct dialogs in webhookUser mode', () => {
+    expect(shouldSkipJoinChatWelcome({
+      dialogId: '1',
+      chatType: 'user',
+      webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+      dmPolicy: 'webhookUser',
+    })).toBe(false);
+  });
+});
+
 // ─── handleWebhookRequest ────────────────────────────────────────────────────
 
 describe('handleWebhookRequest', () => {
+  afterEach(() => {
+    __setGatewayStateForTests(null);
+  });
+
   function mockReq(method: string, body?: string): IncomingMessage {
     const stream = new PassThrough();
     if (body) {
@@ -330,6 +472,71 @@ describe('handleWebhookRequest', () => {
     expect(res._statusCode).toBe(503);
     expect(res._body).toBe('Channel not started');
   });
+
+  it('returns fetch mode acknowledgement when gateway runs in fetch mode', async () => {
+    __setGatewayStateForTests({
+      eventMode: 'fetch',
+      inboundHandler: { handleWebhook: vi.fn() },
+    } as never);
+
+    const req = mockReq('POST', '{"event":"test"}');
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(res._statusCode).toBe(200);
+    expect(res._body).toBe('FETCH mode active');
+  });
+
+  it('returns 400 when webhook payload is invalid', async () => {
+    const handleWebhook = vi.fn().mockResolvedValue(false);
+    __setGatewayStateForTests({
+      eventMode: 'webhook',
+      inboundHandler: { handleWebhook },
+    } as never);
+
+    const req = mockReq('POST', 'not-json');
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(handleWebhook).toHaveBeenCalledWith('not-json');
+    expect(res._statusCode).toBe(400);
+    expect(res._body).toBe('Invalid webhook payload');
+  });
+
+  it('returns 500 when webhook processing throws', async () => {
+    const handleWebhook = vi.fn().mockRejectedValue(new Error('boom'));
+    __setGatewayStateForTests({
+      eventMode: 'webhook',
+      inboundHandler: { handleWebhook },
+    } as never);
+
+    const req = mockReq('POST', '{"event":"test"}');
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(res._statusCode).toBe(500);
+    expect(res._body).toBe('Webhook processing failed');
+  });
+
+  it('rejects oversized webhook bodies with 413', async () => {
+    const handleWebhook = vi.fn();
+    __setGatewayStateForTests({
+      eventMode: 'webhook',
+      inboundHandler: { handleWebhook },
+    } as never);
+
+    const req = mockReq('POST', 'x'.repeat((1024 * 1024) + 1));
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(handleWebhook).not.toHaveBeenCalled();
+    expect(res._statusCode).toBe(413);
+    expect(res._body).toBe('Payload Too Large');
+  });
 });
 
 // ─── bitrix24Plugin structure ────────────────────────────────────────────────
@@ -347,32 +554,46 @@ describe('bitrix24Plugin', () => {
     });
 
     it('declares capabilities', () => {
-      expect(bitrix24Plugin.capabilities.chatTypes).toEqual(['direct', 'group']);
+      expect(bitrix24Plugin.capabilities.chatTypes).toEqual(['direct']);
       expect(bitrix24Plugin.capabilities.media).toBe(true);
-      expect(bitrix24Plugin.capabilities.reactions).toBe(false);
+      expect(bitrix24Plugin.capabilities.reactions).toBe(true);
       expect(bitrix24Plugin.capabilities.threads).toBe(false);
       expect(bitrix24Plugin.capabilities.nativeCommands).toBe(true);
     });
   });
 
   describe('security', () => {
-    it('resolveDmPolicy returns policy object with configured policy', () => {
+    it('resolveDmPolicy returns webhookUser policy when configured', () => {
       const result = bitrix24Plugin.security.resolveDmPolicy({
-        account: { config: { dmPolicy: 'allowlist', allowFrom: ['1'] } },
+        account: { config: { dmPolicy: 'webhookUser', allowFrom: ['bitrix24:42', '42', 'b24:7'] } },
       });
-      expect(result.policy).toBe('allowlist');
-      expect(result.allowFrom).toEqual(['1']);
+      expect(result.policy).toBe('webhookUser');
+      expect(result.allowFrom).toEqual(['42', '7']);
       expect(result.policyPath).toBe('channels.bitrix24.dmPolicy');
-      expect(result.allowFromPath).toBe('channels.bitrix24.');
+      expect(result.allowFromPath).toBe('channels.bitrix24.allowFrom');
       expect(result.approveHint).toContain('openclaw pairing approve bitrix24');
     });
 
-    it('resolveDmPolicy defaults to pairing', () => {
+    it('resolveDmPolicy defaults to webhookUser', () => {
       const result = bitrix24Plugin.security.resolveDmPolicy({});
-      expect(result.policy).toBe('pairing');
+      expect(result.policy).toBe('webhookUser');
       expect(result.allowFrom).toEqual([]);
     });
 
+    it('resolveDmPolicy reads allowFrom from cfg when account is omitted', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({
+        cfg: {
+          channels: {
+            bitrix24: {
+              allowFrom: ['bx24:100', '100', 'bitrix24:42'],
+            },
+          },
+        },
+      });
+
+      expect(result.allowFrom).toEqual(['100', '42']);
+    });
+
     it('resolveDmPolicy normalizeEntry strips prefixes', () => {
       const result = bitrix24Plugin.security.resolveDmPolicy({});
       expect(result.normalizeEntry('bitrix24:42')).toBe('42');

package/tests/commands.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { buildCommandsHelpText, formatModelsCommandReply } from '../src/commands.js';
+
+describe('buildCommandsHelpText', () => {
+  it('builds concise Russian help for keyboard commands', () => {
+    const text = buildCommandsHelpText('ru', { concise: true });
+
+    expect(text).toContain('[B]Основные команды[/B]');
+    expect(text).toContain('[send=/status]/status[/send]');
+    expect(text).toContain('[send=/commands]/commands[/send]');
+    expect(text).toContain('[put=/models ]/models[/put]');
+    expect(text).toContain('[COLOR=#6C788A]Полный список:[/COLOR] [send=/commands]');
+  });
+
+  it('builds full Russian commands list', () => {
+    const text = buildCommandsHelpText('ru');
+
+    expect(text).toContain('[B]Доступные команды[/B]');
+    expect(text).toContain('[B]Справка и статус[/B]');
+    expect(text).toContain('[send=/help]/help[/send]');
+    expect(text).toContain('[send=/export-session]/export-session[/send]');
+    expect(text).toContain('[COLOR=#6C788A]Параметры: off | tokens | full | cost[/COLOR]');
+  });
+
+  it('falls back to English text', () => {
+    const text = buildCommandsHelpText('en', { concise: true });
+
+    expect(text).toContain('[B]Key commands[/B]');
+    expect(text).toContain('[COLOR=#6C788A]Full list:[/COLOR] [send=/commands]');
+  });
+});
+
+describe('formatModelsCommandReply', () => {
+  it('formats provider summary into interactive Bitrix text', () => {
+    const text = formatModelsCommandReply(
+      [
+        'Providers:',
+        '• openai (36)',
+        '• anthropic (23)',
+        '',
+        'Use: /models <provider>',
+        'Switch: /model <provider/model>',
+      ].join('\n'),
+      'ru',
+    );
+
+    expect(text).toContain('[B]Провайдеры[/B]');
+    expect(text).toContain('[send=/models openai]openai[/send]');
+    expect(text).toContain('[send=/models anthropic]anthropic[/send]');
+    expect(text).toContain('[put=/models ]/models <provider>[/put]');
+    expect(text).toContain('[put=/model ]/model <provider/model>[/put]');
+  });
+
+  it('returns null for unrelated text', () => {
+    expect(formatModelsCommandReply('Status ok', 'ru')).toBeNull();
+  });
+});

package/tests/config.test.ts

@@ -6,11 +6,13 @@ const mockCfg = {
     bitrix24: {
       webhookUrl: 'https://test.bitrix24.com/rest/1/abc123/',
       botName: 'TestBot',
-      dmPolicy: 'open',
+      dmPolicy: 'pairing',
+      allowFrom: ['bitrix24:1'],
       accounts: {
         portal2: {
           webhookUrl: 'https://portal2.bitrix24.com/rest/1/xyz789/',
           botName: 'Portal2Bot',
+          allowFrom: ['bitrix24:2'],
         },
       },
     },
@@ -22,12 +24,14 @@ describe('getConfig', () => {
     const cfg = getConfig(mockCfg);
     expect(cfg.webhookUrl).toBe('https://test.bitrix24.com/rest/1/abc123/');
     expect(cfg.botName).toBe('TestBot');
+    expect(cfg.allowFrom).toEqual(['bitrix24:1']);
   });
 
   it('returns account-specific config', () => {
     const cfg = getConfig(mockCfg, 'portal2');
     expect(cfg.webhookUrl).toBe('https://portal2.bitrix24.com/rest/1/xyz789/');
     expect(cfg.botName).toBe('Portal2Bot');
+    expect(cfg.allowFrom).toEqual(['bitrix24:2']);
   });
 
   it('returns empty config when no bitrix24 section', () => {

package/tests/i18n.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveLocale,
+  welcomeMessage,
+  onboardingMessage,
+  personalBotOwnerOnly,
+  forwardedMessageUnsupported,
+  replyMessageUnsupported,
+} from '../src/i18n.js';
+
+describe('i18n welcome messages', () => {
+  it('resolves locale to two-letter lowercase code', () => {
+    expect(resolveLocale('RU')).toBe('ru');
+    expect(resolveLocale('en_US')).toBe('en');
+    expect(resolveLocale(undefined)).toBe('en');
+  });
+
+  it('returns localized Russian welcome message', () => {
+    expect(welcomeMessage('ru', 'OpenClaw')).toContain('OpenClaw готов');
+  });
+
+  it('falls back to English welcome message for unknown locale', () => {
+    expect(welcomeMessage('zz', 'OpenClaw')).toBe(
+      'OpenClaw ready. Send me a message or pick a command below.',
+    );
+  });
+
+  it('returns pairing onboarding message when dmPolicy is pairing', () => {
+    expect(onboardingMessage('ru', 'OpenClaw', 'pairing')).toContain('код привязки');
+    expect(onboardingMessage('en', 'OpenClaw', 'pairing')).toContain('pairing code');
+  });
+
+  it('returns localized personal bot access denied message', () => {
+    expect(personalBotOwnerOnly('ru')).toContain('персональный');
+    expect(personalBotOwnerOnly('en')).toContain('personal');
+  });
+
+  it('returns localized reply unsupported message', () => {
+    expect(replyMessageUnsupported('ru')).toContain('пока не поддерживаются');
+    expect(replyMessageUnsupported('en')).toContain('not supported');
+  });
+
+  it('returns localized forwarded message unsupported message', () => {
+    expect(forwardedMessageUnsupported('ru')).toContain('Пересланные сообщения');
+    expect(forwardedMessageUnsupported('en')).toContain('Forwarded messages');
+  });
+});