@ihazz/bitrix24 0.1.5 → 0.1.6

package/tests/channel.test.ts

@@ -0,0 +1,538 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Readable, PassThrough } from 'node:stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import {
+  convertButtonsToKeyboard,
+  extractKeyboardFromPayload,
+  handleWebhookRequest,
+  bitrix24Plugin,
+} from '../src/channel.js';
+import type { KeyboardButton, KeyboardNewline, B24Keyboard } from '../src/types.js';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+const silentLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+function isButton(item: KeyboardButton | KeyboardNewline): item is KeyboardButton {
+  return !('TYPE' in item);
+}
+
+function isNewline(item: KeyboardButton | KeyboardNewline): item is KeyboardNewline {
+  return 'TYPE' in item && item.TYPE === 'NEWLINE';
+}
+
+// ─── convertButtonsToKeyboard ────────────────────────────────────────────────
+
+describe('convertButtonsToKeyboard', () => {
+  it('converts a single button with slash command', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Help', callback_data: '/help' }],
+    ]);
+
+    expect(kb).toHaveLength(1);
+    const btn = kb[0];
+    expect(isButton(btn)).toBe(true);
+    if (isButton(btn)) {
+      expect(btn.TEXT).toBe('Help');
+      expect(btn.COMMAND).toBe('help');
+      expect(btn.COMMAND_PARAMS).toBeUndefined();
+      expect(btn.DISPLAY).toBe('LINE');
+    }
+  });
+
+  it('converts slash command with params', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Set Model', callback_data: '/model gpt-4o' }],
+    ]);
+
+    expect(kb).toHaveLength(1);
+    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' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.COMMAND).toBe('think');
+      expect(btn.COMMAND_PARAMS).toBe('high extra');
+    }
+  });
+
+  it('converts non-slash callback_data to ACTION PUT', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Click me', callback_data: 'some_value' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.COMMAND).toBeUndefined();
+      expect(btn.ACTION).toBe('PUT');
+      expect(btn.ACTION_VALUE).toBe('some_value');
+    }
+  });
+
+  it('handles button without callback_data', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Plain' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.TEXT).toBe('Plain');
+      expect(btn.COMMAND).toBeUndefined();
+      expect(btn.ACTION).toBeUndefined();
+    }
+  });
+
+  it('maps primary style to BG_COLOR_TOKEN', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Go', callback_data: '/start', style: 'primary' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.BG_COLOR_TOKEN).toBe('primary');
+    }
+  });
+
+  it('maps attention style to alert BG_COLOR_TOKEN', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Stop', callback_data: '/stop', style: 'attention' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.BG_COLOR_TOKEN).toBe('alert');
+    }
+  });
+
+  it('maps danger style to alert BG_COLOR_TOKEN', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Delete', callback_data: '/reset', style: 'danger' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.BG_COLOR_TOKEN).toBe('alert');
+    }
+  });
+
+  it('does not set BG_COLOR_TOKEN for unknown style', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'Btn', callback_data: '/ok', style: 'custom' }],
+    ]);
+
+    const btn = kb[0];
+    if (isButton(btn)) {
+      expect(btn.BG_COLOR_TOKEN).toBeUndefined();
+    }
+  });
+
+  it('adds NEWLINE between rows', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'A', callback_data: '/a' }],
+      [{ text: 'B', callback_data: '/b' }],
+    ]);
+
+    // [btn, NEWLINE, btn] = 3 items
+    expect(kb).toHaveLength(3);
+    expect(isButton(kb[0])).toBe(true);
+    expect(isNewline(kb[1])).toBe(true);
+    expect(isButton(kb[2])).toBe(true);
+  });
+
+  it('handles multiple buttons per row', () => {
+    const kb = convertButtonsToKeyboard([
+      [
+        { text: 'Yes', callback_data: '/yes' },
+        { text: 'No', callback_data: '/no' },
+      ],
+    ]);
+
+    // Single row with 2 buttons, no NEWLINE
+    expect(kb).toHaveLength(2);
+    expect(isButton(kb[0])).toBe(true);
+    expect(isButton(kb[1])).toBe(true);
+    if (isButton(kb[0])) expect(kb[0].COMMAND).toBe('yes');
+    if (isButton(kb[1])) expect(kb[1].COMMAND).toBe('no');
+  });
+
+  it('handles multiple rows with multiple buttons', () => {
+    const kb = convertButtonsToKeyboard([
+      [{ text: 'A' }, { text: 'B' }],
+      [{ text: 'C' }],
+      [{ text: 'D' }, { text: 'E' }, { text: 'F' }],
+    ]);
+
+    // Row1(2) + NL + Row2(1) + NL + Row3(3) = 2+1+1+1+3 = 8
+    expect(kb).toHaveLength(8);
+    expect(isNewline(kb[2])).toBe(true);
+    expect(isNewline(kb[4])).toBe(true);
+  });
+
+  it('handles empty rows array', () => {
+    const kb = convertButtonsToKeyboard([]);
+    expect(kb).toHaveLength(0);
+  });
+
+  it('handles empty row inside rows', () => {
+    const kb = convertButtonsToKeyboard([[]]);
+    expect(kb).toHaveLength(0);
+  });
+});
+
+// ─── extractKeyboardFromPayload ──────────────────────────────────────────────
+
+describe('extractKeyboardFromPayload', () => {
+  it('returns undefined when no channelData', () => {
+    expect(extractKeyboardFromPayload({})).toBeUndefined();
+  });
+
+  it('returns undefined when channelData is empty', () => {
+    expect(extractKeyboardFromPayload({ channelData: {} })).toBeUndefined();
+  });
+
+  it('returns undefined when channelData buttons is empty array', () => {
+    const result = extractKeyboardFromPayload({
+      channelData: { telegram: { buttons: [] } },
+    });
+    expect(result).toBeUndefined();
+  });
+
+  it('extracts direct B24 keyboard from channelData.bitrix24', () => {
+    const directKeyboard: B24Keyboard = [
+      { TEXT: 'Direct', COMMAND: 'test' },
+    ];
+
+    const result = extractKeyboardFromPayload({
+      channelData: { bitrix24: { keyboard: directKeyboard } },
+    });
+
+    expect(result).toEqual(directKeyboard);
+  });
+
+  it('prefers B24 keyboard over generic channel buttons', () => {
+    const directKeyboard: B24Keyboard = [{ TEXT: 'B24' }];
+
+    const result = extractKeyboardFromPayload({
+      channelData: {
+        bitrix24: { keyboard: directKeyboard },
+        telegram: { buttons: [[{ text: 'TG', callback_data: '/tg' }]] },
+      },
+    });
+
+    expect(result).toEqual(directKeyboard);
+  });
+
+  it('converts channel buttons to B24 keyboard', () => {
+    const result = extractKeyboardFromPayload({
+      channelData: {
+        telegram: {
+          buttons: [[{ text: 'Help', callback_data: '/help' }]],
+        },
+      },
+    });
+
+    expect(result).toBeDefined();
+    expect(result).toHaveLength(1);
+    if (result && isButton(result[0])) {
+      expect(result[0].TEXT).toBe('Help');
+      expect(result[0].COMMAND).toBe('help');
+    }
+  });
+
+  it('converts multi-row channel buttons', () => {
+    const result = extractKeyboardFromPayload({
+      channelData: {
+        telegram: {
+          buttons: [
+            [{ text: 'A', callback_data: '/a' }],
+            [{ text: 'B', callback_data: '/b' }],
+          ],
+        },
+      },
+    });
+
+    // [btn, NEWLINE, btn]
+    expect(result).toHaveLength(3);
+  });
+
+  it('returns undefined when bitrix24.keyboard is empty', () => {
+    const result = extractKeyboardFromPayload({
+      channelData: { bitrix24: { keyboard: [] } },
+    });
+    expect(result).toBeUndefined();
+  });
+
+  it('ignores unrelated channelData keys', () => {
+    const result = extractKeyboardFromPayload({
+      channelData: { discord: { something: true } },
+    });
+    expect(result).toBeUndefined();
+  });
+});
+
+// ─── handleWebhookRequest ────────────────────────────────────────────────────
+
+describe('handleWebhookRequest', () => {
+  function mockReq(method: string, body?: string): IncomingMessage {
+    const stream = new PassThrough();
+    if (body) {
+      stream.end(body);
+    } else {
+      stream.end();
+    }
+    (stream as unknown as Record<string, unknown>).method = method;
+    return stream as unknown as IncomingMessage;
+  }
+
+  function mockRes(): ServerResponse & { _statusCode: number; _body: string; _headers: Record<string, string> } {
+    const res = {
+      _statusCode: 200,
+      _body: '',
+      _headers: {} as Record<string, string>,
+      get statusCode() { return this._statusCode; },
+      set statusCode(v: number) { this._statusCode = v; },
+      setHeader(key: string, val: string) { this._headers[key] = val; },
+      end(body?: string) { this._body = body ?? ''; },
+    };
+    return res as unknown as ServerResponse & { _statusCode: number; _body: string; _headers: Record<string, string> };
+  }
+
+  it('rejects non-POST with 405', async () => {
+    const req = mockReq('GET');
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(res._statusCode).toBe(405);
+    expect(res._body).toBe('Method Not Allowed');
+  });
+
+  it('returns 503 when gateway not started', async () => {
+    const req = mockReq('POST', 'event=test');
+    const res = mockRes();
+
+    await handleWebhookRequest(req, res);
+
+    expect(res._statusCode).toBe(503);
+    expect(res._body).toBe('Channel not started');
+  });
+});
+
+// ─── bitrix24Plugin structure ────────────────────────────────────────────────
+
+describe('bitrix24Plugin', () => {
+  describe('metadata', () => {
+    it('has correct id', () => {
+      expect(bitrix24Plugin.id).toBe('bitrix24');
+    });
+
+    it('has correct meta', () => {
+      expect(bitrix24Plugin.meta.id).toBe('bitrix24');
+      expect(bitrix24Plugin.meta.label).toBe('Bitrix24');
+      expect(bitrix24Plugin.meta.aliases).toEqual(['b24', 'bx24']);
+    });
+
+    it('declares capabilities', () => {
+      expect(bitrix24Plugin.capabilities.chatTypes).toEqual(['direct', 'group']);
+      expect(bitrix24Plugin.capabilities.media).toBe(true);
+      expect(bitrix24Plugin.capabilities.reactions).toBe(false);
+      expect(bitrix24Plugin.capabilities.threads).toBe(false);
+      expect(bitrix24Plugin.capabilities.nativeCommands).toBe(true);
+    });
+  });
+
+  describe('security', () => {
+    it('resolveDmPolicy returns policy object with configured policy', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({
+        account: { config: { dmPolicy: 'allowlist', allowFrom: ['1'] } },
+      });
+      expect(result.policy).toBe('allowlist');
+      expect(result.allowFrom).toEqual(['1']);
+      expect(result.policyPath).toBe('channels.bitrix24.dmPolicy');
+      expect(result.allowFromPath).toBe('channels.bitrix24.');
+      expect(result.approveHint).toContain('openclaw pairing approve bitrix24');
+    });
+
+    it('resolveDmPolicy defaults to pairing', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({});
+      expect(result.policy).toBe('pairing');
+      expect(result.allowFrom).toEqual([]);
+    });
+
+    it('resolveDmPolicy normalizeEntry strips prefixes', () => {
+      const result = bitrix24Plugin.security.resolveDmPolicy({});
+      expect(result.normalizeEntry('bitrix24:42')).toBe('42');
+      expect(result.normalizeEntry('b24:42')).toBe('42');
+      expect(result.normalizeEntry('BX24:7')).toBe('7');
+      expect(result.normalizeEntry('42')).toBe('42');
+    });
+
+    it('normalizeAllowFrom strips bitrix24: prefix', () => {
+      expect(bitrix24Plugin.security.normalizeAllowFrom('bitrix24:42')).toBe('42');
+    });
+
+    it('normalizeAllowFrom strips b24: prefix', () => {
+      expect(bitrix24Plugin.security.normalizeAllowFrom('b24:42')).toBe('42');
+    });
+
+    it('normalizeAllowFrom strips bx24: prefix', () => {
+      expect(bitrix24Plugin.security.normalizeAllowFrom('bx24:42')).toBe('42');
+    });
+
+    it('normalizeAllowFrom keeps plain id', () => {
+      expect(bitrix24Plugin.security.normalizeAllowFrom('42')).toBe('42');
+    });
+  });
+
+  describe('pairing adapter', () => {
+    it('has correct idLabel', () => {
+      expect(bitrix24Plugin.pairing.idLabel).toBe('bitrix24UserId');
+    });
+
+    it('normalizeAllowEntry strips prefixes', () => {
+      expect(bitrix24Plugin.pairing.normalizeAllowEntry!('bitrix24:42')).toBe('42');
+      expect(bitrix24Plugin.pairing.normalizeAllowEntry!('b24:42')).toBe('42');
+      expect(bitrix24Plugin.pairing.normalizeAllowEntry!('BX24:7')).toBe('7');
+      expect(bitrix24Plugin.pairing.normalizeAllowEntry!('42')).toBe('42');
+    });
+
+    it('has notifyApproval function', () => {
+      expect(typeof bitrix24Plugin.pairing.notifyApproval).toBe('function');
+    });
+  });
+
+  describe('outbound', () => {
+    it('has direct delivery mode', () => {
+      expect(bitrix24Plugin.outbound.deliveryMode).toBe('direct');
+    });
+
+    it('sendText returns error when gateway not started', async () => {
+      const result = await bitrix24Plugin.outbound.sendText({
+        text: 'Hello',
+        context: {
+          channel: 'bitrix24',
+          senderId: '1',
+          senderName: 'Test',
+          chatId: '1',
+          chatInternalId: '100',
+          messageId: '1',
+          text: 'Hello',
+          isDm: true,
+          isGroup: false,
+          media: [],
+          raw: {} as any,
+          botToken: 'token',
+          userToken: 'utoken',
+          clientEndpoint: 'https://test.bitrix24.com/rest/',
+          botId: 1,
+          memberId: 'mem1',
+        },
+        account: { config: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } },
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe('Gateway not started');
+      expect(result.channel).toBe('bitrix24');
+    });
+
+    it('sendPayload returns error when gateway not started', async () => {
+      const result = await bitrix24Plugin.outbound.sendPayload({
+        text: 'Hello',
+        channelData: { telegram: { buttons: [[{ text: 'OK' }]] } },
+        context: {
+          channel: 'bitrix24',
+          senderId: '1',
+          senderName: 'Test',
+          chatId: '1',
+          chatInternalId: '100',
+          messageId: '1',
+          text: 'Hello',
+          isDm: true,
+          isGroup: false,
+          media: [],
+          raw: {} as any,
+          botToken: 'token',
+          userToken: 'utoken',
+          clientEndpoint: 'https://test.bitrix24.com/rest/',
+          botId: 1,
+          memberId: 'mem1',
+        },
+        account: { config: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } },
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe('Gateway not started');
+    });
+  });
+
+  describe('config', () => {
+    it('listAccountIds returns empty for empty config', () => {
+      expect(bitrix24Plugin.config.listAccountIds({})).toEqual([]);
+    });
+
+    it('listAccountIds returns default when webhookUrl present', () => {
+      const cfg = {
+        channels: {
+          bitrix24: {
+            webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+          },
+        },
+      };
+      expect(bitrix24Plugin.config.listAccountIds(cfg)).toEqual(['default']);
+    });
+
+    it('resolveAccount returns config', () => {
+      const cfg = {
+        channels: {
+          bitrix24: {
+            webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+            botName: 'TestBot',
+          },
+        },
+      };
+      const account = bitrix24Plugin.config.resolveAccount(cfg);
+      expect(account.accountId).toBe('default');
+      expect(account.config.webhookUrl).toBe('https://test.bitrix24.com/rest/1/token/');
+      expect(account.config.botName).toBe('TestBot');
+      expect(account.configured).toBe(true);
+      expect(account.enabled).toBe(true);
+    });
+  });
+});
+
+// ─── gateway.startAccount ────────────────────────────────────────────────────
+
+describe('gateway.startAccount', () => {
+  it('skips when webhookUrl not configured', async () => {
+    const logger = { ...silentLogger };
+
+    const result = await bitrix24Plugin.gateway.startAccount({
+      cfg: { channels: { bitrix24: {} } },
+      accountId: 'test',
+      account: { config: {} },
+      runtime: {},
+      abortSignal: new AbortController().signal,
+      log: logger,
+    });
+
+    // Should return undefined (early return, no promise)
+    expect(result).toBeUndefined();
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('no webhookUrl configured'),
+    );
+  });
+});

package/tests/inbound-handler.test.ts

@@ -60,7 +60,7 @@ describe('InboundHandler', () => {
     expect(onMessage).toHaveBeenCalledOnce();
   });
 
-  it('respects access control', async () => {
+  it('dispatches all messages (access control handled externally)', async () => {
     const onMessage = vi.fn();
     handler = new InboundHandler({
       config: { dmPolicy: 'allowlist', allowFrom: ['99'] },
@@ -69,7 +69,8 @@ describe('InboundHandler', () => {
     });
 
     await handler.handleWebhook(textFixture);
-    expect(onMessage).not.toHaveBeenCalled();
+    // Access control is now handled in channel.ts onMessage callback, not in InboundHandler
+    expect(onMessage).toHaveBeenCalledOnce();
   });
 
   it('dispatches join chat events', async () => {
@@ -156,6 +157,7 @@ describe('normalizeMessageEvent', () => {
       extension: 'txt',
       size: 101,
       type: 'file',
+      urlDownload: 'https://test.bitrix24.com/disk/downloadFile/94611/',
     });
   });
 });