@ihazz/bitrix24 0.2.4 → 1.0.0

package/tests/index.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import bitrix24Module, { collectBitrix24CallbackPaths } from '../index.ts';
+
+const runtime = {
+  config: { loadConfig: () => ({}) },
+  channel: {
+    routing: { resolveAgentRoute: vi.fn() },
+    reply: {
+      finalizeInboundContext: vi.fn(),
+      dispatchReplyWithBufferedBlockDispatcher: vi.fn(),
+    },
+    session: { recordInboundSession: vi.fn() },
+    pairing: {
+      readAllowFromStore: vi.fn(),
+      upsertPairingRequest: vi.fn(),
+      buildPairingReply: vi.fn(),
+    },
+  },
+  logging: { getChildLogger: vi.fn() },
+};
+
+describe('collectBitrix24CallbackPaths', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('collects unique callback paths from base config and accounts', () => {
+    const paths = collectBitrix24CallbackPaths({
+      channels: {
+        bitrix24: {
+          callbackUrl: 'https://example.com/hooks/bitrix24',
+          accounts: {
+            a: { callbackUrl: 'https://example.com/hooks/bitrix24-a' },
+            b: { callbackUrl: 'https://other.example.com/hooks/bitrix24-a' },
+          },
+        },
+      },
+    });
+
+    expect(paths).toEqual(['/hooks/bitrix24', '/hooks/bitrix24-a']);
+  });
+
+  it('skips invalid callback urls without dropping valid ones', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const paths = collectBitrix24CallbackPaths({
+      channels: {
+        bitrix24: {
+          callbackUrl: 'not-a-url',
+          accounts: {
+            a: { callbackUrl: 'https://example.com/hooks/bitrix24-a' },
+          },
+        },
+      },
+    });
+
+    expect(paths).toEqual(['/hooks/bitrix24-a']);
+    expect(warnSpy).toHaveBeenCalledOnce();
+  });
+});
+
+describe('bitrix24 index module', () => {
+  it('registers HTTP routes for every configured callback path', () => {
+    const registerChannel = vi.fn();
+    const registerHttpRoute = vi.fn();
+
+    bitrix24Module.register({
+      config: {
+        channels: {
+          bitrix24: {
+            callbackUrl: 'https://example.com/hooks/bitrix24',
+            accounts: {
+              a: { callbackUrl: 'https://example.com/hooks/bitrix24-a' },
+            },
+          },
+        },
+      },
+      runtime: runtime as never,
+      registerChannel,
+      registerHttpRoute,
+    });
+
+    expect(registerChannel).toHaveBeenCalledOnce();
+    expect(registerHttpRoute).toHaveBeenCalledTimes(2);
+    expect(registerHttpRoute).toHaveBeenNthCalledWith(1, expect.objectContaining({
+      path: '/hooks/bitrix24',
+      auth: 'plugin',
+    }));
+    expect(registerHttpRoute).toHaveBeenNthCalledWith(2, expect.objectContaining({
+      path: '/hooks/bitrix24-a',
+      auth: 'plugin',
+    }));
+  });
+});

package/tests/media-service.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { existsSync, unlinkSync } from 'node:fs';
-import { MediaService } from '../src/media-service.js';
+import { join } from 'node:path';
+import { MediaService, resolveManagedMediaDir } from '../src/media-service.js';
 import { Bitrix24Api } from '../src/api.js';
 
 const silentLogger = {
@@ -13,12 +14,13 @@ const silentLogger = {
 // Mock the API
 function mockApi(): Bitrix24Api {
   return {
-    getFileInfo: vi.fn().mockResolvedValue({
-      DOWNLOAD_URL: 'https://example.com/download/test.txt?token=abc',
+    getFileDownloadUrl: vi.fn().mockResolvedValue('https://example.com/download/test.txt?token=abc'),
+    uploadFile: vi.fn().mockResolvedValue({
+      file: { id: 100, name: 'upload-test.txt' },
+      messageId: 100,
+      chatId: 42,
+      dialogId: 'chat40985',
     }),
-    getChatFolder: vi.fn().mockResolvedValue(42),
-    uploadFile: vi.fn().mockResolvedValue(100),
-    commitFileToChat: vi.fn().mockResolvedValue(true),
   } as unknown as Bitrix24Api;
 }
 
@@ -26,8 +28,10 @@ describe('MediaService', () => {
   let service: MediaService;
   let api: Bitrix24Api;
   const savedPaths: string[] = [];
+  const tempStateDir = '/tmp/openclaw-test-state';
 
   beforeEach(() => {
+    process.env.OPENCLAW_STATE_DIR = tempStateDir;
     api = mockApi();
     service = new MediaService(api, silentLogger);
     vi.clearAllMocks();
@@ -39,6 +43,27 @@ describe('MediaService', () => {
       try { unlinkSync(p); } catch { /* ignore */ }
     }
     savedPaths.length = 0;
+    delete process.env.OPENCLAW_STATE_DIR;
+    delete process.env.CLAWDBOT_STATE_DIR;
+  });
+
+  describe('resolveManagedMediaDir', () => {
+    it('uses OpenClaw state media directory by default', () => {
+      const mediaDir = resolveManagedMediaDir({
+        HOME: '/tmp/test-home',
+      } as NodeJS.ProcessEnv);
+
+      expect(mediaDir).toBe('/tmp/test-home/.openclaw/media/bitrix24');
+    });
+
+    it('prefers OPENCLAW_STATE_DIR when it is configured', () => {
+      const mediaDir = resolveManagedMediaDir({
+        OPENCLAW_STATE_DIR: '/srv/openclaw-state',
+        HOME: '/tmp/test-home',
+      } as NodeJS.ProcessEnv);
+
+      expect(mediaDir).toBe('/srv/openclaw-state/media/bitrix24');
+    });
   });
 
   describe('downloadMedia', () => {
@@ -52,20 +77,23 @@ describe('MediaService', () => {
         fileId: '123',
         fileName: 'test.txt',
         extension: 'txt',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'user_token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).not.toBeNull();
       expect(result!.contentType).toBe('text/plain');
       expect(result!.name).toBe('test.txt');
       expect(result!.path).toContain('test.txt');
+      expect(result!.path.startsWith(join(tempStateDir, 'media', 'bitrix24'))).toBe(true);
       expect(existsSync(result!.path)).toBe(true);
       savedPaths.push(result!.path);
 
-      expect(api.getFileInfo).toHaveBeenCalledWith(
-        'https://test.bitrix24.com/rest/',
-        'user_token',
+      expect(api.getFileDownloadUrl).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/1/token/',
+        { botId: 7, botToken: 'bot_token' },
+        'chat40985',
         123,
       );
     });
@@ -79,8 +107,9 @@ describe('MediaService', () => {
         fileId: '456',
         fileName: 'photo.jpg',
         extension: 'jpg',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).not.toBeNull();
@@ -88,8 +117,55 @@ describe('MediaService', () => {
       if (result) savedPaths.push(result.path);
     });
 
+    it('cleans up managed downloaded temp files', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(Buffer.from('cleanup me'), { status: 200 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '654',
+        fileName: 'cleanup.txt',
+        extension: 'txt',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
+      });
+
+      expect(result).not.toBeNull();
+      expect(existsSync(result!.path)).toBe(true);
+
+      await service.cleanupDownloadedMedia([result!.path]);
+
+      expect(existsSync(result!.path)).toBe(false);
+    });
+
+    it('rewrites private Bitrix download URLs to webhook origin', async () => {
+      (api.getFileDownloadUrl as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
+        'https://192.168.50.50/rest/1/token/download/?token=abc',
+      );
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(Buffer.from('hello world'), { status: 200 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '777',
+        fileName: 'private.txt',
+        extension: 'txt',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: '1',
+      });
+
+      expect(result).not.toBeNull();
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/1/token/download/?token=abc',
+        expect.objectContaining({ signal: expect.any(AbortSignal) }),
+      );
+      if (result) savedPaths.push(result.path);
+    });
+
     it('returns null when API fails', async () => {
-      (api.getFileInfo as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+      (api.getFileDownloadUrl as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
         new Error('API error'),
       );
 
@@ -97,8 +173,9 @@ describe('MediaService', () => {
         fileId: '789',
         fileName: 'fail.txt',
         extension: 'txt',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).toBeNull();
@@ -106,14 +183,15 @@ describe('MediaService', () => {
     });
 
     it('returns null when no DOWNLOAD_URL', async () => {
-      (api.getFileInfo as ReturnType<typeof vi.fn>).mockResolvedValueOnce({});
+      (api.getFileDownloadUrl as ReturnType<typeof vi.fn>).mockResolvedValueOnce('');
 
       const result = await service.downloadMedia({
         fileId: '789',
         fileName: 'nourl.txt',
         extension: 'txt',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).toBeNull();
@@ -128,8 +206,9 @@ describe('MediaService', () => {
         fileId: '789',
         fileName: 'missing.txt',
         extension: 'txt',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).toBeNull();
@@ -144,18 +223,41 @@ describe('MediaService', () => {
         fileId: '100',
         fileName: 'file.xyz',
         extension: 'xyz',
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        userToken: 'token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
       expect(result).not.toBeNull();
       expect(result!.contentType).toBe('application/octet-stream');
       if (result) savedPaths.push(result.path);
     });
+
+    it('prefers response content type when extension is unknown', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(Buffer.from([0xff, 0xd8, 0xff]), {
+          status: 200,
+          headers: { 'content-type': 'image/jpeg; charset=binary' },
+        }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '101',
+        fileName: 'forwarded-file',
+        extension: '',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.contentType).toBe('image/jpeg');
+      if (result) savedPaths.push(result.path);
+    });
   });
 
   describe('uploadMediaToChat', () => {
-    it('uploads file through 3-step process', async () => {
+    it('uploads file through imbot.v2.File.upload', async () => {
       // Create a temp file to upload
       const { writeFileSync, mkdirSync } = await import('node:fs');
       const { join } = await import('node:path');
@@ -169,35 +271,28 @@ describe('MediaService', () => {
       const result = await service.uploadMediaToChat({
         localPath: testPath,
         fileName: 'upload-test.txt',
-        chatId: 40985,
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        botToken: 'bot_token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
+        message: 'hello',
       });
 
-      expect(result).toBe(true);
-      expect(api.getChatFolder).toHaveBeenCalledWith(
-        'https://test.bitrix24.com/rest/',
-        'bot_token',
-        40985,
-      );
+      expect(result).toEqual({ ok: true, messageId: 100 });
       expect(api.uploadFile).toHaveBeenCalledWith(
-        'https://test.bitrix24.com/rest/',
-        'bot_token',
-        42,
-        'upload-test.txt',
-        expect.any(Buffer),
-      );
-      expect(api.commitFileToChat).toHaveBeenCalledWith(
-        'https://test.bitrix24.com/rest/',
-        'bot_token',
-        40985,
-        100,
+        'https://test.bitrix24.com/rest/1/token/',
+        { botId: 7, botToken: 'bot_token' },
+        'chat40985',
+        {
+          name: 'upload-test.txt',
+          content: Buffer.from('upload content').toString('base64'),
+          message: 'hello',
+        },
       );
     });
 
-    it('returns false when getChatFolder fails', async () => {
-      (api.getChatFolder as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
-        new Error('folder error'),
+    it('returns { ok: false } when upload fails', async () => {
+      (api.uploadFile as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+        new Error('upload error'),
       );
 
       const { writeFileSync, mkdirSync } = await import('node:fs');
@@ -212,12 +307,12 @@ describe('MediaService', () => {
       const result = await service.uploadMediaToChat({
         localPath: testPath,
         fileName: 'fail-upload.txt',
-        chatId: 40985,
-        clientEndpoint: 'https://test.bitrix24.com/rest/',
-        botToken: 'bot_token',
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        bot: { botId: 7, botToken: 'bot_token' },
+        dialogId: 'chat40985',
       });
 
-      expect(result).toBe(false);
+      expect(result).toEqual({ ok: false });
       expect(silentLogger.error).toHaveBeenCalled();
     });
   });

package/tests/message-utils.test.ts

@@ -26,6 +26,14 @@ describe('markdownToBbCode', () => {
     expect(markdownToBbCode('Use `console.log`')).toBe('Use [CODE]console.log[/CODE]');
   });
 
+  it('renders slash commands as bold burgundy inline accents', () => {
+    expect(markdownToBbCode('Try `/status`')).toBe('Try [B][COLOR=#7A1F3D]/status[/COLOR][/B]');
+  });
+
+  it('renders short acronyms as bold burgundy inline accents', () => {
+    expect(markdownToBbCode('Use `API` here')).toBe('Use [B][COLOR=#7A1F3D]API[/COLOR][/B] here');
+  });
+
   it('converts code blocks', () => {
     const md = '```js\nconst x = 1;\n```';
     const expected = '[CODE]const x = 1;[/CODE]';
@@ -37,10 +45,66 @@ describe('markdownToBbCode', () => {
       .toBe('[URL=https://google.com]Google[/URL]');
   });
 
+  it('converts markdown images to lowercase img tag without title text', () => {
+    expect(markdownToBbCode('![Заголовок изображения](https://via.placeholder.com/150 "Заголовок изображения")'))
+      .toBe('[img size=medium]https://via.placeholder.com/150#image.jpg [/img]');
+  });
+
+  it('keeps supported image extensions unchanged', () => {
+    expect(markdownToBbCode('![x](https://example.com/image.png)'))
+      .toBe('[img size=medium]https://example.com/image.png [/img]');
+  });
+
+  it('adds image.jpg suffix for unsupported image extensions', () => {
+    expect(markdownToBbCode('![x](https://mcgrp.ru/img/2017_05/img_1007484.avif)'))
+      .toBe('[img size=medium]https://mcgrp.ru/img/2017_05/img_1007484.avif#image.jpg [/img]');
+  });
+
   it('converts blockquotes', () => {
     expect(markdownToBbCode('> This is a quote')).toBe('>>This is a quote');
   });
 
+  it('converts nested blockquotes to Bitrix-compatible quoted blocks', () => {
+    expect(markdownToBbCode([
+      '> цитата уровня 1',
+      '>> цитата уровня два',
+    ].join('\n'))).toBe([
+      '>>цитата уровня 1',
+      '>>------------------------------------------------------',
+      '>>цитата уровня два',
+      '>>------------------------------------------------------',
+    ].join('\n'));
+  });
+
+  it('skips empty spacer lines inside nested blockquotes', () => {
+    expect(markdownToBbCode([
+      '> Это первая цитата уровня 1.',
+      '>',
+      '>> Это вторая цитата уровня 2, вложенная в первую.',
+    ].join('\n'))).toBe([
+      '>>Это первая цитата уровня 1.',
+      '>>------------------------------------------------------',
+      '>>Это вторая цитата уровня 2, вложенная в первую.',
+      '>>------------------------------------------------------',
+    ].join('\n'));
+  });
+
+  it('converts GFM tables to simplified plain text tables', () => {
+    const input = [
+      '| Заголовок 1 | Заголовок 2 |',
+      '| ----------- | ----------- |',
+      '| Ячейка 1    | Ячейка 2    |',
+      '| Ячейка 3    | Ячейка 4    |',
+    ].join('\n');
+
+    expect(markdownToBbCode(input)).toBe([
+      'Заголовок 1 | Заголовок 2',
+      '_________________________',
+      'Ячейка 1    | Ячейка 2',
+      'Ячейка 3    | Ячейка 4',
+    ].join('\n'));
+  });
+
   it('handles mixed formatting', () => {
     const input = '**Bold** and *italic* with `code`';
     const expected = '[B]Bold[/B] and [I]italic[/I] with [CODE]code[/CODE]';

package/tests/polling-service.test.ts

@@ -0,0 +1,77 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { PollingService } from '../src/polling-service.js';
+import type { Bitrix24Api } from '../src/api.js';
+
+const silentLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+describe('PollingService', () => {
+  let tempHome = '';
+  const originalHome = process.env.HOME;
+
+  afterEach(() => {
+    if (tempHome) {
+      rmSync(tempHome, { recursive: true, force: true });
+      tempHome = '';
+    }
+
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+
+    vi.clearAllMocks();
+  });
+
+  it('persists offset only up to the last successfully processed event', async () => {
+    tempHome = mkdtempSync(join(tmpdir(), 'b24-polling-'));
+    process.env.HOME = tempHome;
+
+    const abortController = new AbortController();
+    const fetchEvents = vi.fn().mockResolvedValue({
+      events: [
+        { eventId: 10, type: 'ONE', date: '', data: {} },
+        { eventId: 11, type: 'TWO', date: '', data: {} },
+      ],
+      lastEventId: 11,
+      hasMore: false,
+    });
+
+    const api = { fetchEvents } as unknown as Bitrix24Api;
+    const onEvent = vi.fn(async (event: { eventId: number }) => {
+      if (event.eventId === 11) {
+        abortController.abort();
+        throw new Error('boom');
+      }
+    });
+
+    const service = new PollingService({
+      api,
+      webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+      bot: { botId: 7, botToken: 'bot_token' },
+      accountId: 'default',
+      pollingIntervalMs: 10,
+      pollingFastIntervalMs: 10,
+      onEvent: onEvent as never,
+      abortSignal: abortController.signal,
+      logger: silentLogger,
+    });
+
+    await service.start();
+
+    const statePath = join(tempHome, '.openclaw', 'state', 'bitrix24', 'poll-offset-default.json');
+    const state = JSON.parse(readFileSync(statePath, 'utf-8')) as { offset: number };
+
+    expect(fetchEvents).toHaveBeenCalledOnce();
+    expect(onEvent).toHaveBeenCalledTimes(2);
+    expect(state.offset).toBe(11);
+  });
+});

package/tests/rate-limiter.test.ts

@@ -42,11 +42,11 @@ describe('RateLimiter', () => {
     expect(limiter.pending).toBe(0);
   });
 
-  it('resolves pending on destroy', async () => {
+  it('rejects pending on destroy', async () => {
     limiter = new RateLimiter({ maxPerSecond: 1 });
     await limiter.acquire();
     const p = limiter.acquire();
     limiter.destroy();
-    await p; // Should resolve without hanging
+    await expect(p).rejects.toThrow('RateLimiter destroyed');
   });
 });