@ihazz/bitrix24 0.1.4 → 0.1.6

package/src/channel.ts

@@ -1,12 +1,25 @@
 import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { listAccountIds, resolveAccount, getConfig } from './config.js';
 import { Bitrix24Api } from './api.js';
 import { SendService } from './send-service.js';
+import { MediaService } from './media-service.js';
+import type { DownloadedMedia } from './media-service.js';
 import { InboundHandler } from './inbound-handler.js';
+import { normalizeAllowEntry, checkAccessWithPairing } from './access-control.js';
 import { defaultLogger } from './utils.js';
 import { getBitrix24Runtime } from './runtime.js';
-import type { B24MsgContext, B24JoinChatEvent, Bitrix24AccountConfig } from './types.js';
+import type { ChannelPairingAdapter } from './runtime.js';
+import { OPENCLAW_COMMANDS } from './commands.js';
+import type {
+  B24MsgContext,
+  B24JoinChatEvent,
+  B24CommandEvent,
+  Bitrix24AccountConfig,
+  B24Keyboard,
+  KeyboardButton,
+} from './types.js';
 
 interface Logger {
   info: (...args: unknown[]) => void;
@@ -19,11 +32,89 @@ interface Logger {
 interface GatewayState {
   api: Bitrix24Api;
   sendService: SendService;
+  mediaService: MediaService;
   inboundHandler: InboundHandler;
 }
 
 let gatewayState: GatewayState | null = null;
 
+// ─── Keyboard / Button conversion ────────────────────────────────────────────
+
+/** Generic button format used by OpenClaw channelData. */
+export interface ChannelButton {
+  text: string;
+  callback_data?: string;
+  style?: string;
+}
+
+/**
+ * Convert OpenClaw button rows to B24 flat KEYBOARD array.
+ * Input: Array<Array<{ text, callback_data, style }>>
+ * Output: flat array with { TYPE: 'NEWLINE' } separators between rows.
+ */
+export function convertButtonsToKeyboard(rows: ChannelButton[][]): B24Keyboard {
+  const keyboard: B24Keyboard = [];
+
+  for (let i = 0; i < rows.length; i++) {
+    for (const btn of rows[i]) {
+      const b24Btn: KeyboardButton = { TEXT: btn.text, DISPLAY: 'LINE' };
+
+      if (btn.callback_data?.startsWith('/')) {
+        // Slash command — use COMMAND + COMMAND_PARAMS
+        const parts = btn.callback_data.substring(1).split(' ');
+        b24Btn.COMMAND = parts[0];
+        if (parts.length > 1) {
+          b24Btn.COMMAND_PARAMS = parts.slice(1).join(' ');
+        }
+      } else if (btn.callback_data) {
+        // Non-slash data — insert text into input via PUT action
+        b24Btn.ACTION = 'PUT';
+        b24Btn.ACTION_VALUE = btn.callback_data;
+      }
+
+      if (btn.style === 'primary') {
+        b24Btn.BG_COLOR_TOKEN = 'primary';
+      } else if (btn.style === 'attention' || btn.style === 'danger') {
+        b24Btn.BG_COLOR_TOKEN = 'alert';
+      }
+
+      keyboard.push(b24Btn);
+    }
+
+    // Add NEWLINE separator between rows (not after last row)
+    if (i < rows.length - 1) {
+      keyboard.push({ TYPE: 'NEWLINE' });
+    }
+  }
+
+  return keyboard;
+}
+
+/**
+ * Extract B24 keyboard from a dispatcher payload's channelData.
+ * Checks bitrix24-specific data first, then falls back to OpenClaw generic button format.
+ */
+export function extractKeyboardFromPayload(
+  payload: { channelData?: Record<string, unknown> },
+): B24Keyboard | undefined {
+  const cd = payload.channelData;
+  if (!cd) return undefined;
+
+  // Direct B24 keyboard (future-proof: channelData.bitrix24.keyboard)
+  const b24Data = cd.bitrix24 as { keyboard?: B24Keyboard } | undefined;
+  if (b24Data?.keyboard?.length) {
+    return b24Data.keyboard;
+  }
+
+  // Translate from OpenClaw generic button format (channelData.telegram key)
+  const tgData = cd.telegram as { buttons?: ChannelButton[][] } | undefined;
+  if (tgData?.buttons?.length) {
+    return convertButtonsToKeyboard(tgData.buttons);
+  }
+
+  return undefined;
+}
+
 /**
  * Register or update the bot on the Bitrix24 portal.
  * Checks imbot.bot.list first; if a bot with the same CODE exists, updates it.
@@ -82,6 +173,51 @@ async function ensureBotRegistered(
   }
 }
 
+/**
+ * Register OpenClaw slash commands with the B24 bot.
+ * Runs in the background — errors are logged but don't block startup.
+ */
+async function ensureCommandsRegistered(
+  api: Bitrix24Api,
+  config: Bitrix24AccountConfig,
+  botId: number,
+  logger: Logger,
+): Promise<void> {
+  const { webhookUrl, callbackUrl } = config;
+  if (!webhookUrl || !callbackUrl) return;
+
+  let registered = 0;
+  let skipped = 0;
+
+  for (const cmd of OPENCLAW_COMMANDS) {
+    try {
+      await api.registerCommand(webhookUrl, {
+        BOT_ID: botId,
+        COMMAND: cmd.command,
+        COMMON: 'N',
+        HIDDEN: 'N',
+        EXTRANET_SUPPORT: 'N',
+        LANG: [
+          { LANGUAGE_ID: 'en', TITLE: cmd.en, ...(cmd.params ? { PARAMS: cmd.params } : {}) },
+          { LANGUAGE_ID: 'ru', TITLE: cmd.ru, ...(cmd.params ? { PARAMS: cmd.params } : {}) },
+        ],
+        EVENT_COMMAND_ADD: callbackUrl,
+      });
+      registered++;
+    } catch (err: unknown) {
+      // "WRONG_REQUEST" typically means command already exists
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes('WRONG_REQUEST') || msg.includes('already')) {
+        skipped++;
+      } else {
+        logger.warn(`Failed to register command /${cmd.command}`, err);
+      }
+    }
+  }
+
+  logger.info(`Commands sync: ${registered} registered, ${skipped} already existed (total ${OPENCLAW_COMMANDS.length})`);
+}
+
 /**
  * Handle an incoming HTTP request on the webhook route.
  * Called by the HTTP route registered in index.ts.
@@ -140,7 +276,7 @@ export const bitrix24Plugin = {
 
   capabilities: {
     chatTypes: ['direct', 'group'] as const,
-    media: false,
+    media: true,
     reactions: false,
     threads: false,
     nativeCommands: true,
@@ -153,12 +289,33 @@ export const bitrix24Plugin = {
   },
 
   security: {
-    resolveDmPolicy: (account: { config?: { dmPolicy?: string } }) =>
-      account.config?.dmPolicy ?? 'open',
+    resolveDmPolicy: (params: { cfg?: Record<string, unknown>; accountId?: string; account?: { config?: Record<string, unknown> } }) => ({
+      policy: (params.account?.config?.dmPolicy as string) ?? 'pairing',
+      allowFrom: (params.account?.config?.allowFrom as string[]) ?? [],
+      policyPath: 'channels.bitrix24.dmPolicy',
+      allowFromPath: 'channels.bitrix24.',
+      approveHint: 'openclaw pairing approve bitrix24 <CODE>',
+      normalizeEntry: (raw: string) => raw.replace(/^(bitrix24|b24|bx24):/i, ''),
+    }),
     normalizeAllowFrom: (entry: string) =>
-      entry.replace(/^(bitrix24|b24|bx24):/, ''),
+      entry.replace(/^(bitrix24|b24|bx24):/i, ''),
   },
 
+  pairing: {
+    idLabel: 'bitrix24UserId',
+    normalizeAllowEntry: (entry: string) => normalizeAllowEntry(entry),
+    notifyApproval: async (params: { cfg: Record<string, unknown>; id: string; runtime?: unknown }) => {
+      const { config: acctCfg } = resolveAccount(params.cfg);
+      if (!acctCfg.webhookUrl) return;
+      const api = new Bitrix24Api();
+      try {
+        await api.sendMessage(acctCfg.webhookUrl, params.id, '\u2705 OpenClaw access approved.');
+      } finally {
+        api.destroy();
+      }
+    },
+  } satisfies ChannelPairingAdapter,
+
   outbound: {
     deliveryMode: 'direct' as const,
 
@@ -201,6 +358,55 @@ export const bitrix24Plugin = {
         error: result.error,
       };
     },
+
+    /**
+     * Send a payload with optional channelData (keyboards, etc.) to B24.
+     * Called by OpenClaw when the response includes channelData.
+     */
+    sendPayload: async (params: {
+      text: string;
+      channelData?: Record<string, unknown>;
+      context: B24MsgContext;
+      account: { config: { webhookUrl?: string; showTyping?: boolean } };
+    }) => {
+      const { text, channelData, context, account } = params;
+
+      if (!gatewayState) {
+        return { ok: false, error: 'Gateway not started', channel: 'bitrix24' };
+      }
+
+      const { sendService } = gatewayState;
+
+      const sendCtx = {
+        webhookUrl: account.config.webhookUrl,
+        clientEndpoint: context.clientEndpoint,
+        botToken: context.botToken,
+        dialogId: context.chatId,
+      };
+
+      // Send typing indicator
+      if (account.config.showTyping !== false) {
+        await sendService.sendTyping(sendCtx);
+      }
+
+      // Extract keyboard from channelData
+      const keyboard = channelData
+        ? extractKeyboardFromPayload({ channelData })
+        : undefined;
+
+      const result = await sendService.sendText(
+        sendCtx,
+        text,
+        keyboard ? { keyboard } : undefined,
+      );
+
+      return {
+        ok: result.ok,
+        messageId: result.messageId,
+        channel: 'bitrix24' as const,
+        error: result.error,
+      };
+    },
   },
 
   gateway: {
@@ -230,9 +436,17 @@ export const bitrix24Plugin = {
       const clientId = createHash('md5').update(config.webhookUrl).digest('hex');
       const api = new Bitrix24Api({ logger, clientId });
       const sendService = new SendService(api, logger);
+      const mediaService = new MediaService(api, logger);
 
       // Register or update bot on the B24 portal
-      await ensureBotRegistered(api, config, logger);
+      const botId = await ensureBotRegistered(api, config, logger);
+
+      // Register slash commands (runs in background, doesn't block startup)
+      if (botId) {
+        ensureCommandsRegistered(api, config, botId, logger).catch((err) => {
+          logger.warn('Command registration failed', err);
+        });
+      }
 
       const inboundHandler = new InboundHandler({
         config,
@@ -249,6 +463,64 @@ export const bitrix24Plugin = {
           const runtime = getBitrix24Runtime();
           const cfg = runtime.config.loadConfig();
 
+          // Pairing-aware access control
+          const accessResult = await checkAccessWithPairing({
+            senderId: msgCtx.senderId,
+            config,
+            runtime,
+            accountId: ctx.accountId,
+            pairingAdapter: bitrix24Plugin.pairing,
+            sendReply: async (text: string) => {
+              const replySendCtx = {
+                webhookUrl: config.webhookUrl,
+                clientEndpoint: msgCtx.clientEndpoint,
+                botToken: msgCtx.botToken,
+                dialogId: msgCtx.chatId,
+              };
+              await sendService.sendText(replySendCtx, text, { convertMarkdown: false });
+            },
+            logger,
+          });
+
+          if (accessResult !== 'allow') {
+            logger.debug(`Message blocked (${accessResult})`, { senderId: msgCtx.senderId });
+            return;
+          }
+
+          // Download media files if present
+          let mediaFields: Record<string, unknown> = {};
+          if (msgCtx.media.length > 0) {
+            const downloaded = (await Promise.all(
+              msgCtx.media.map((m) =>
+                mediaService.downloadMedia({
+                  fileId: m.id,
+                  fileName: m.name,
+                  extension: m.extension,
+                  clientEndpoint: msgCtx.clientEndpoint,
+                  userToken: msgCtx.userToken,
+                }),
+              ),
+            )).filter(Boolean) as DownloadedMedia[];
+
+            if (downloaded.length > 0) {
+              mediaFields = {
+                MediaPath: downloaded[0].path,
+                MediaType: downloaded[0].contentType,
+                MediaUrl: downloaded[0].path,
+                MediaPaths: downloaded.map((m) => m.path),
+                MediaUrls: downloaded.map((m) => m.path),
+                MediaTypes: downloaded.map((m) => m.contentType),
+              };
+            }
+          }
+
+          // Use placeholder body for media-only messages
+          let body = msgCtx.text;
+          if (!body && msgCtx.media.length > 0) {
+            const hasImage = msgCtx.media.some((m) => m.type === 'image');
+            body = hasImage ? '<media:image>' : '<media:document>';
+          }
+
           // Resolve which agent handles this conversation
           const route = runtime.channel.routing.resolveAgentRoute({
             cfg,
@@ -268,9 +540,9 @@ export const bitrix24Plugin = {
 
           // Build and finalize inbound context for OpenClaw agent
           const inboundCtx = runtime.channel.reply.finalizeInboundContext({
-            Body: msgCtx.text,
-            BodyForAgent: msgCtx.text,
-            RawBody: msgCtx.text,
+            Body: body,
+            BodyForAgent: body,
+            RawBody: body,
             From: `bitrix24:${msgCtx.chatId}`,
             To: `bitrix24:${msgCtx.chatId}`,
             SessionKey: route.sessionKey,
@@ -284,9 +556,10 @@ export const bitrix24Plugin = {
             MessageSid: msgCtx.messageId,
             Timestamp: Date.now(),
             WasMentioned: false,
-            CommandAuthorized: false,
+            CommandAuthorized: true,
             OriginatingChannel: 'bitrix24',
             OriginatingTo: `bitrix24:${msgCtx.chatId}`,
+            ...mediaFields,
           });
 
           const sendCtx = {
@@ -303,8 +576,21 @@ export const bitrix24Plugin = {
               cfg,
               dispatcherOptions: {
                 deliver: async (payload) => {
+                  // Send media if present in reply
+                  const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+                  for (const mediaUrl of mediaUrls) {
+                    await mediaService.uploadMediaToChat({
+                      localPath: mediaUrl,
+                      fileName: basename(mediaUrl),
+                      chatId: Number(msgCtx.chatInternalId),
+                      clientEndpoint: msgCtx.clientEndpoint,
+                      botToken: msgCtx.botToken,
+                    });
+                  }
+                  // Send text if present
                   if (payload.text) {
-                    await sendService.sendText(sendCtx, payload.text);
+                    const keyboard = extractKeyboardFromPayload(payload);
+                    await sendService.sendText(sendCtx, payload.text, keyboard ? { keyboard } : undefined);
                   }
                 },
                 onReplyStart: async () => {
@@ -322,6 +608,113 @@ export const bitrix24Plugin = {
           }
         },
 
+        onCommand: async (event: B24CommandEvent) => {
+          const cmdEntry = Object.values(event.data.COMMAND)[0];
+          if (!cmdEntry) {
+            logger.warn('No command entry in ONIMCOMMANDADD event');
+            return;
+          }
+
+          const commandName = cmdEntry.COMMAND;
+          const commandParams = cmdEntry.COMMAND_PARAMS?.trim() ?? '';
+          const commandText = commandParams
+            ? `/${commandName} ${commandParams}`
+            : `/${commandName}`;
+
+          const senderId = String(event.data.PARAMS.FROM_USER_ID);
+          const dialogId = event.data.PARAMS.DIALOG_ID;
+          const isDm = event.data.PARAMS.CHAT_TYPE === 'P';
+          const user = event.data.USER;
+
+          logger.info('Inbound command', { commandName, commandParams, senderId, dialogId });
+
+          const runtime = getBitrix24Runtime();
+          const cfg = runtime.config.loadConfig();
+
+          // Pairing-aware access control (commands don't send pairing replies)
+          const accessResult = await checkAccessWithPairing({
+            senderId,
+            config,
+            runtime,
+            accountId: ctx.accountId,
+            pairingAdapter: bitrix24Plugin.pairing,
+            sendReply: async () => {},
+            logger,
+          });
+
+          if (accessResult !== 'allow') {
+            logger.debug(`Command blocked (${accessResult})`, { senderId });
+            return;
+          }
+
+          const route = runtime.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: 'bitrix24',
+            accountId: ctx.accountId,
+            peer: { kind: isDm ? 'direct' : 'group', id: dialogId },
+          });
+
+          // Native commands use a separate slash-command session
+          const slashSessionKey = `bitrix24:slash:${senderId}`;
+
+          const inboundCtx = runtime.channel.reply.finalizeInboundContext({
+            Body: commandText,
+            BodyForAgent: commandText,
+            RawBody: commandText,
+            CommandBody: commandText,
+            CommandAuthorized: true,
+            CommandSource: 'native',
+            CommandTargetSessionKey: route.sessionKey,
+            From: `bitrix24:${dialogId}`,
+            To: `slash:${senderId}`,
+            SessionKey: slashSessionKey,
+            AccountId: route.accountId,
+            ChatType: isDm ? 'direct' : 'group',
+            ConversationLabel: user.NAME,
+            SenderName: user.NAME,
+            SenderId: senderId,
+            Provider: 'bitrix24',
+            Surface: 'bitrix24',
+            MessageSid: String(event.data.PARAMS.MESSAGE_ID),
+            Timestamp: Date.now(),
+            WasMentioned: true,
+            OriginatingChannel: 'bitrix24',
+            OriginatingTo: `bitrix24:${dialogId}`,
+          });
+
+          const sendCtx = {
+            webhookUrl: config.webhookUrl,
+            clientEndpoint: (cmdEntry.client_endpoint as string | undefined) ?? event.auth.client_endpoint,
+            botToken: cmdEntry.access_token,
+            dialogId,
+          };
+
+          try {
+            await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+              ctx: inboundCtx,
+              cfg,
+              dispatcherOptions: {
+                deliver: async (payload) => {
+                  if (payload.text) {
+                    const keyboard = extractKeyboardFromPayload(payload);
+                    await sendService.sendText(sendCtx, payload.text, keyboard ? { keyboard } : undefined);
+                  }
+                },
+                onReplyStart: async () => {
+                  if (config.showTyping !== false) {
+                    await sendService.sendTyping(sendCtx);
+                  }
+                },
+                onError: (err) => {
+                  logger.error('Error delivering command reply to B24', err);
+                },
+              },
+            });
+          } catch (err) {
+            logger.error('Error dispatching command to agent', err);
+          }
+        },
+
         onJoinChat: async (event: B24JoinChatEvent) => {
           logger.info('Bot joined chat', {
             dialogId: event.data.PARAMS.DIALOG_ID,
@@ -344,7 +737,7 @@ export const bitrix24Plugin = {
         },
       });
 
-      gatewayState = { api, sendService, inboundHandler };
+      gatewayState = { api, sendService, mediaService, inboundHandler };
 
       logger.info(`[${ctx.accountId}] Bitrix24 channel started`);
 

package/src/commands.ts

@@ -0,0 +1,60 @@
+/**
+ * OpenClaw bot commands to register with Bitrix24.
+ *
+ * Standard OpenClaw bot commands registered via imbot.command.register.
+ */
+
+export interface BotCommandDef {
+  command: string;
+  en: string;
+  ru: string;
+  params?: string;
+}
+
+/**
+ * Standard OpenClaw commands.
+ * Excludes: focus/unfocus/agents (Discord-specific), allowlist/bash (text-only scope).
+ */
+export const OPENCLAW_COMMANDS: BotCommandDef[] = [
+  // ── Status ──
+  { command: 'help', en: 'Show available commands', ru: 'Показать доступные команды' },
+  { command: 'commands', en: 'List all slash commands', ru: 'Список всех команд' },
+  { command: 'status', en: 'Show current status', ru: 'Показать текущий статус' },
+  { command: 'context', en: 'Explain how context is built', ru: 'Объяснить построение контекста' },
+  { command: 'whoami', en: 'Show your sender ID', ru: 'Показать ваш ID' },
+  { command: 'usage', en: 'Usage and cost summary', ru: 'Использование и стоимость', params: 'off|tokens|full|cost' },
+
+  // ── Session ──
+  { command: 'new', en: 'Start a new session', ru: 'Начать новую сессию' },
+  { command: 'reset', en: 'Reset the current session', ru: 'Сбросить текущую сессию' },
+  { command: 'stop', en: 'Stop the current run', ru: 'Остановить текущий запуск' },
+  { command: 'compact', en: 'Compact the session context', ru: 'Сжать контекст сессии', params: 'instructions' },
+  { command: 'session', en: 'Manage session settings', ru: 'Настройки сессии', params: 'ttl|...' },
+
+  // ── Options ──
+  { command: 'model', en: 'Show or set the model', ru: 'Показать/сменить модель', params: 'model name' },
+  { command: 'models', en: 'List available models', ru: 'Список моделей', params: 'provider' },
+  { command: 'think', en: 'Set thinking level', ru: 'Уровень размышлений', params: 'off|low|medium|high' },
+  { command: 'verbose', en: 'Toggle verbose mode', ru: 'Подробный режим', params: 'on|off' },
+  { command: 'reasoning', en: 'Toggle reasoning visibility', ru: 'Видимость рассуждений', params: 'on|off|stream' },
+  { command: 'elevated', en: 'Toggle elevated mode', ru: 'Режим с расширенными правами', params: 'on|off|ask|full' },
+  { command: 'exec', en: 'Set exec defaults', ru: 'Настройки выполнения', params: 'host|security|ask|node' },
+  { command: 'queue', en: 'Adjust queue settings', ru: 'Настройки очереди', params: 'mode|debounce|cap|drop' },
+
+  // ── Management ──
+  { command: 'config', en: 'Show or set config values', ru: 'Показать/задать конфигурацию', params: 'show|get|set|unset' },
+  { command: 'debug', en: 'Set runtime debug overrides', ru: 'Отладочные настройки', params: 'show|reset|set|unset' },
+  { command: 'approve', en: 'Approve or deny exec requests', ru: 'Одобрить/отклонить запросы' },
+  { command: 'activation', en: 'Set group activation mode', ru: 'Режим активации в группах', params: 'mention|always' },
+  { command: 'send', en: 'Set send policy', ru: 'Политика отправки', params: 'on|off|inherit' },
+  { command: 'subagents', en: 'Manage subagent runs', ru: 'Управление субагентами' },
+  { command: 'kill', en: 'Kill a running subagent', ru: 'Остановить субагента', params: 'id|all' },
+  { command: 'steer', en: 'Send guidance to a subagent', ru: 'Направить субагента', params: 'message' },
+
+  // ── Tools ──
+  { command: 'skill', en: 'Run a skill by name', ru: 'Запустить навык', params: 'name' },
+  { command: 'restart', en: 'Restart OpenClaw', ru: 'Перезапустить OpenClaw' },
+
+  // ── Export ──
+  { command: 'export-session', en: 'Export session to HTML', ru: 'Экспорт сессии в HTML' },
+];

package/src/config-schema.ts

@@ -6,9 +6,8 @@ const AccountSchema = z.object({
   botName: z.string().optional().default('OpenClaw'),
   botCode: z.string().optional().default('openclaw'),
   botAvatar: z.string().optional(),
-  callbackPath: z.string().optional().default('/hooks/bitrix24'),
   callbackUrl: z.string().url().optional(),
-  dmPolicy: z.enum(['open', 'allowlist', 'pairing']).optional().default('open'),
+  dmPolicy: z.enum(['open', 'allowlist', 'pairing']).optional().default('pairing'),
   allowFrom: z.array(z.string()).optional(),
   showTyping: z.boolean().optional().default(true),
   streamUpdates: z.boolean().optional().default(false),

package/src/inbound-handler.ts

@@ -11,7 +11,6 @@ import type {
   B24MediaItem,
 } from './types.js';
 import { Dedup } from './dedup.js';
-import { checkAccess } from './access-control.js';
 import type { Bitrix24AccountConfig } from './types.js';
 import { defaultLogger } from './utils.js';
 
@@ -109,14 +108,6 @@ export class InboundHandler {
       return true;
     }
 
-    const senderId = String(params.FROM_USER_ID);
-
-    // Access control
-    if (!checkAccess(senderId, this.config)) {
-      this.logger.debug(`Access denied for user ${senderId}`);
-      return true;
-    }
-
     // Extract bot entry
     const botEntry = extractBotEntry(event.data.BOT);
     if (!botEntry) {
@@ -183,5 +174,6 @@ function normalizeFiles(files?: Record<string, B24File>): B24MediaItem[] {
     extension: file.extension,
     size: file.size,
     type: file.image ? 'image' as const : 'file' as const,
+    urlDownload: file.urlDownload || undefined,
   }));
 }