@ihazz/bitrix24 1.1.13 → 1.1.14

package/src/i18n.ts

@@ -32,6 +32,19 @@ export function mediaDownloadFailed(lang: string | undefined, fileNames: string)
   return resolve(I18N_MEDIA_DOWNLOAD_FAILED, lang)(fileNames);
 }
 
+const I18N_EMPTY_REPLY_FALLBACK: Record<string, string> = {
+  en: 'I could not send the reply. Please try again.',
+  ru: 'Не удалось отправить ответ. Попробуйте еще раз.',
+  de: 'Die Antwort konnte nicht gesendet werden. Bitte versuchen Sie es erneut.',
+  es: 'No pude enviar la respuesta. Intentalo de nuevo.',
+  fr: 'Je n ai pas pu envoyer la reponse. Veuillez reessayer.',
+  pt: 'Nao foi possivel enviar a resposta. Tente novamente.',
+};
+
+export function emptyReplyFallback(lang: string | undefined): string {
+  return resolve(I18N_EMPTY_REPLY_FALLBACK, lang);
+}
+
 // ─── Group chat unsupported ──────────────────────────────────────────────────
 
 const I18N_GROUP_CHAT_UNSUPPORTED: Record<string, string> = {

package/src/inbound-handler.ts

@@ -19,6 +19,8 @@ import type {
 import { Dedup } from './dedup.js';
 import { createVerboseLogger, defaultLogger } from './utils.js';
 
+const USER_SCOPE_GROUP_MIRROR_DEBOUNCE_MS = 1200;
+
 /** Normalized fetch command context passed to onFetchCommand callback. */
 export interface FetchCommandContext {
   commandId: number;
@@ -77,6 +79,11 @@ export class InboundHandler {
   private config: Bitrix24AccountConfig;
   private logger: Logger;
   private verboseLog: boolean;
+  private knownBotConversations = new Map<string, number>();
+  private pendingUserScopeGroupMessages = new Map<string, {
+    timer: ReturnType<typeof setTimeout>;
+    resolve: (value: boolean) => void;
+  }>();
   private onMessage?: (ctx: B24MsgContext) => void | Promise<void>;
   private onJoinChat?: (ctx: FetchJoinChatContext) => void | Promise<void>;
   private onReactionChange?: (ctx: FetchReactionContext) => void | Promise<void>;
@@ -95,6 +102,112 @@ export class InboundHandler {
     this.onBotDelete = opts.onBotDelete;
   }
 
+  private pruneKnownBotConversations(now = Date.now()): void {
+    for (const [key, expiresAt] of this.knownBotConversations.entries()) {
+      if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+        this.knownBotConversations.delete(key);
+      }
+    }
+  }
+
+  private buildConversationMirrorKeys(dialogId: string, chatId: string): string[] {
+    const keys: string[] = [];
+    const normalizedDialogId = String(dialogId ?? '').trim();
+    const normalizedChatId = String(chatId ?? '').trim();
+
+    if (normalizedDialogId) {
+      keys.push(`dialog:${normalizedDialogId}`);
+    }
+
+    if (normalizedChatId) {
+      keys.push(`chat:${normalizedChatId}`);
+    }
+
+    return keys;
+  }
+
+  private rememberBotConversation(dialogId: string, chatId: string): void {
+    const keys = this.buildConversationMirrorKeys(dialogId, chatId);
+    if (keys.length === 0) {
+      return;
+    }
+
+    this.pruneKnownBotConversations();
+    const expiresAt = Date.now() + (5 * 60 * 1000);
+    keys.forEach((key) => {
+      this.knownBotConversations.set(key, expiresAt);
+    });
+  }
+
+  private isKnownBotConversation(dialogId: string, chatId: string): boolean {
+    const keys = this.buildConversationMirrorKeys(dialogId, chatId);
+    if (keys.length === 0) {
+      return false;
+    }
+
+    this.pruneKnownBotConversations();
+    return keys.some((key) => this.knownBotConversations.has(key));
+  }
+
+  private shouldSkipMirroredUserEvent(params: {
+    dialogId: string;
+    chatId: string;
+    isP2P: boolean;
+    botId: string;
+  }): boolean {
+    if (!this.config.agentMode) {
+      return false;
+    }
+
+    if (params.isP2P) {
+      return params.dialogId === params.botId;
+    }
+
+    return this.isKnownBotConversation(params.dialogId, params.chatId);
+  }
+
+  private buildPendingUserScopeGroupMessageKey(messageId: string, chatId: string): string {
+    return `${chatId}:${messageId}`;
+  }
+
+  private consumePendingUserScopeGroupMessage(messageId: string, chatId: string): boolean {
+    const key = this.buildPendingUserScopeGroupMessageKey(messageId, chatId);
+    const pendingEntry = this.pendingUserScopeGroupMessages.get(key);
+    if (!pendingEntry) {
+      return false;
+    }
+
+    clearTimeout(pendingEntry.timer);
+    this.pendingUserScopeGroupMessages.delete(key);
+    pendingEntry.resolve(true);
+    return true;
+  }
+
+  private deferPotentialMirroredUserScopeGroupMessage(params: {
+    messageId: string;
+    chatId: string;
+    run: () => Promise<void>;
+  }): Promise<boolean> {
+    const key = this.buildPendingUserScopeGroupMessageKey(params.messageId, params.chatId);
+    const existingEntry = this.pendingUserScopeGroupMessages.get(key);
+    if (existingEntry) {
+      return Promise.resolve(true);
+    }
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(async () => {
+        this.pendingUserScopeGroupMessages.delete(key);
+        try {
+          await params.run();
+        } finally {
+          resolve(true);
+        }
+      }, USER_SCOPE_GROUP_MIRROR_DEBOUNCE_MS);
+
+      this.pendingUserScopeGroupMessages.set(key, { timer, resolve });
+    });
+  }
+
   // ─── V2 FETCH mode event handling ───────────────────────────────────────
 
   /**
@@ -167,18 +280,49 @@ export class InboundHandler {
     }
     const messageId = String(rawMessageId);
 
-    const dedupKey = `${eventScope}:${messageId}`;
-    if (this.dedup.isDuplicate(dedupKey)) {
-      this.logger.debug(`Fetch: duplicate message ${messageId} for scope ${eventScope}, skipping`);
-      return true;
-    }
-
     const dialogId = String(data.chat?.dialogId ?? data.message.chatId ?? data.user.id ?? '');
     if (!dialogId) {
       this.logger.warn('Fetch: message event has no dialogId, skipping');
       return true;
     }
+    const chatInternalId = String(data.message?.chatId ?? data.chat?.id ?? dialogId);
     const isP2P = !dialogId.startsWith('chat');
+    const normalizedBotId = String(fetchCtx.botId);
+    const normalizedSenderId = String(data.user?.id ?? '');
+    const normalizedAuthorId = String(data.message?.authorId ?? '');
+
+    if (eventScope === 'bot' || normalizedSenderId === normalizedBotId || normalizedAuthorId === normalizedBotId) {
+      this.rememberBotConversation(dialogId, chatInternalId);
+      if (eventScope === 'bot' && this.consumePendingUserScopeGroupMessage(messageId, chatInternalId)) {
+        this.logger.debug(`Fetch: canceled pending mirrored user-scope group message ${messageId}`);
+      }
+    }
+
+    if (isBitrixBackendServiceMessage(data.message?.text ?? '', data.message?.params)) {
+      this.logger.debug(`Fetch: skipping Bitrix backend service message ${messageId}`);
+      return true;
+    }
+
+    if (normalizedSenderId === normalizedBotId || normalizedAuthorId === normalizedBotId) {
+      this.logger.debug(`Fetch: skipping self-authored message ${messageId} for scope ${eventScope}`);
+      return true;
+    }
+
+    if (eventScope === 'user' && this.shouldSkipMirroredUserEvent({
+      dialogId,
+      chatId: chatInternalId,
+      isP2P,
+      botId: normalizedBotId,
+    })) {
+      this.logger.debug(`Fetch: skipping mirrored user-scope message ${messageId}`);
+      return true;
+    }
+
+    const dedupKey = `${eventScope}:${messageId}`;
+    if (this.dedup.isDuplicate(dedupKey)) {
+      this.logger.debug(`Fetch: duplicate message ${messageId} for scope ${eventScope}, skipping`);
+      return true;
+    }
 
     // Extract file attachments from message params
     const media = extractFilesFromParams(data.message.params);
@@ -208,7 +352,7 @@ export class InboundHandler {
       senderName: data.user?.name ?? dialogId,
       senderFirstName: data.user?.firstName,
       chatId: dialogId,
-      chatInternalId: String(data.message?.chatId ?? dialogId),
+      chatInternalId,
       chatName: data.chat?.name,
       chatType: data.chat?.type,
       messageId,
@@ -231,6 +375,16 @@ export class InboundHandler {
       memberId: '',
     };
 
+    if (eventScope === 'user' && !isP2P && this.config.agentMode && !this.isKnownBotConversation(dialogId, chatInternalId)) {
+      return this.deferPotentialMirroredUserScopeGroupMessage({
+        messageId,
+        chatId: chatInternalId,
+        run: async () => {
+          await this.onMessage?.(ctx);
+        },
+      });
+    }
+
     await this.onMessage?.(ctx);
     return true;
   }
@@ -269,14 +423,44 @@ export class InboundHandler {
       this.logger.warn('Fetch: reaction event has no dialogId, skipping', { eventId: item.eventId });
       return true;
     }
+    const chatId = String(data.chat?.id ?? data.message.chatId ?? dialogId);
+    const isP2P = !dialogId.startsWith('chat');
+    const normalizedBotId = String(fetchCtx.botId);
+    const normalizedSenderId = String(data.user.id ?? '');
+    const normalizedMessageAuthorId = String(data.message.authorId ?? '');
+
+    if (eventScope === 'bot' || normalizedSenderId === normalizedBotId || normalizedMessageAuthorId === normalizedBotId) {
+      this.rememberBotConversation(dialogId, chatId);
+    }
+
+    if (normalizedSenderId === normalizedBotId) {
+      this.logger.debug(`Fetch: skipping self-authored reaction ${messageId} for scope ${eventScope}`);
+      return true;
+    }
+
+    if (eventScope === 'user' && this.shouldSkipMirroredUserEvent({
+      dialogId,
+      chatId,
+      isP2P,
+      botId: normalizedBotId,
+    })) {
+      this.logger.debug(`Fetch: skipping mirrored user-scope reaction ${messageId}`);
+      return true;
+    }
+
+    const dedupKey = `${eventScope}:reaction:${messageId}:${normalizedSenderId}:${action}:${String(data.reaction ?? '')}`;
+    if (this.dedup.isDuplicate(dedupKey)) {
+      this.logger.debug(`Fetch: duplicate reaction ${messageId} for scope ${eventScope}, skipping`);
+      return true;
+    }
 
     await this.onReactionChange?.({
       eventScope,
-      senderId: String(data.user.id ?? ''),
+      senderId: normalizedSenderId,
       dialogId,
-      chatId: String(data.chat?.id ?? data.message.chatId ?? dialogId),
+      chatId,
       messageId,
-      messageAuthorId: String(data.message.authorId ?? ''),
+      messageAuthorId: normalizedMessageAuthorId,
       reaction: String(data.reaction ?? ''),
       action,
       language: data.language,
@@ -300,6 +484,8 @@ export class InboundHandler {
       return true;
     }
 
+    this.rememberBotConversation(data.dialogId, String(data.chat.id ?? data.dialogId));
+
     const joinCtx: FetchJoinChatContext = {
       senderId: String(data.user?.id ?? data.dialogId),
       dialogId: data.dialogId,
@@ -348,6 +534,7 @@ export class InboundHandler {
       return true;
     }
     const isP2P = !dialogId.startsWith('chat');
+    this.rememberBotConversation(dialogId, String(data.chat?.id ?? data.message?.chatId ?? dialogId));
 
     const cmdCtx: FetchCommandContext = {
       commandId,
@@ -448,6 +635,12 @@ export class InboundHandler {
 
   destroy(): void {
     this.dedup.destroy();
+    this.knownBotConversations.clear();
+    for (const pendingEntry of this.pendingUserScopeGroupMessages.values()) {
+      clearTimeout(pendingEntry.timer);
+      pendingEntry.resolve(true);
+    }
+    this.pendingUserScopeGroupMessages.clear();
   }
 }
 
@@ -466,6 +659,50 @@ function normalizeMessageParams(params: B24V2MessageParams | undefined): Record<
   return params;
 }
 
+function extractAttachBlockMessages(params: B24V2MessageParams | undefined): string[] {
+  const normalizedParams = normalizeMessageParams(params);
+  const rawAttach = normalizedParams.ATTACH;
+  if (!Array.isArray(rawAttach)) {
+    return [];
+  }
+
+  return rawAttach.flatMap((attachItem) => {
+    if (!attachItem || typeof attachItem !== 'object') {
+      return [];
+    }
+
+    const rawBlocks = (attachItem as Record<string, unknown>).BLOCKS;
+    if (!Array.isArray(rawBlocks)) {
+      return [];
+    }
+
+    return rawBlocks
+      .map((block) => (
+        block && typeof block === 'object'
+          ? String((block as Record<string, unknown>).MESSAGE ?? '').trim().toLowerCase()
+          : ''
+      ))
+      .filter(Boolean);
+  });
+}
+
+function isBitrixBackendServiceMessage(text: string, params: B24V2MessageParams | undefined): boolean {
+  if (text.trim().toLowerCase() !== 'backend') {
+    return false;
+  }
+
+  const blockMessages = extractAttachBlockMessages(params);
+  if (blockMessages.length === 0) {
+    return false;
+  }
+
+  const hasEvent = blockMessages.some((message) => message.startsWith('event:'));
+  const hasTool = blockMessages.some((message) => message === 'tool: im');
+  const hasCategory = blockMessages.some((message) => message === 'category: chat');
+
+  return hasEvent && hasTool && hasCategory;
+}
+
 function normalizeFileRecords(rawFiles: unknown): Record<string, Record<string, unknown>> {
   if (!rawFiles || typeof rawFiles !== 'object') {
     return {};

package/src/media-service.ts

@@ -166,6 +166,7 @@ const MAX_FILE_SIZE = 100 * 1024 * 1024;
 
 /** Timeout for media download requests (30 seconds). */
 const DOWNLOAD_TIMEOUT_MS = 30_000;
+const DOWNLOADED_MEDIA_CLEANUP_DELAY_MS = 30 * 60 * 1000;
 
 const EMPTY_BUFFER = Buffer.alloc(0);
 const MANAGED_FILE_NAME_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}_(.+)$/i;
@@ -186,6 +187,7 @@ export class MediaService {
   private api: Bitrix24Api;
   private logger: Logger;
   private dirReady = false;
+  private pendingDownloadedMediaCleanupTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
   constructor(api: Bitrix24Api, logger?: Logger) {
     this.api = api;
@@ -607,6 +609,12 @@ export class MediaService {
     const uniquePaths = [...new Set(paths)];
 
     for (const filePath of uniquePaths) {
+      const scheduledCleanup = this.pendingDownloadedMediaCleanupTimers.get(filePath);
+      if (scheduledCleanup) {
+        clearTimeout(scheduledCleanup);
+        this.pendingDownloadedMediaCleanupTimers.delete(filePath);
+      }
+
       if (!(await this.isManagedMediaPath(filePath))) {
         this.logger.debug('Skipping cleanup for unmanaged media path', { path: filePath });
         continue;
@@ -630,6 +638,37 @@ export class MediaService {
     }
   }
 
+  scheduleDownloadedMediaCleanup(
+    paths: string[],
+    delayMs = DOWNLOADED_MEDIA_CLEANUP_DELAY_MS,
+  ): void {
+    const normalizedDelayMs = Math.max(0, Number(delayMs) || 0);
+    const uniquePaths = [...new Set(paths.map((path) => path.trim()).filter(Boolean))];
+
+    for (const filePath of uniquePaths) {
+      const scheduledCleanup = this.pendingDownloadedMediaCleanupTimers.get(filePath);
+      if (scheduledCleanup) {
+        clearTimeout(scheduledCleanup);
+      }
+
+      const timer = setTimeout(() => {
+        this.pendingDownloadedMediaCleanupTimers.delete(filePath);
+        this.cleanupDownloadedMedia([filePath]).catch((error) => {
+          this.logger.warn('Failed to cleanup downloaded media after delay', {
+            path: filePath,
+            error: serializeError(error),
+          });
+        });
+      }, normalizedDelayMs);
+
+      if (timer && typeof timer === 'object' && 'unref' in timer) {
+        timer.unref();
+      }
+
+      this.pendingDownloadedMediaCleanupTimers.set(filePath, timer);
+    }
+  }
+
   private async isManagedMediaPath(filePath: string): Promise<boolean> {
     try {
       const resolvedPath = await realpath(filePath);

package/src/message-utils.ts

@@ -4,6 +4,7 @@ import type { KeyboardButton, B24Keyboard } from './types.js';
 
 const PH_ESC = '\x00ESC';    // escape sequences
 const PH_BBCODE = '\x00BB';  // existing BBCode blocks
+const PH_ENTITY = '\x00BE';  // existing Bitrix entity mentions
 const PH_FCODE = '\x00FC';   // fenced code blocks
 const PH_ICODE = '\x00IC';   // inline code
 const PH_HR = '\x00HR';      // horizontal rules
@@ -62,6 +63,7 @@ export function markdownToBbCode(md: string): string {
     return `${PH_ICODE}${inlineCodes.length - 1}\x00`;
   });
   const tableSeparators: string[] = [];
+  const bitrixEntityBlocks: string[] = [];
 
   // ── Phase 2: Block rules (line-level, order matters) ──────────────────────
 
@@ -173,6 +175,13 @@ export function markdownToBbCode(md: string): string {
   // 3j. Autolink email: <user@example.com> → [URL]mailto:user@example.com[/URL]
   text = text.replace(/<([a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,})>/g, '[URL]mailto:$1[/URL]');
 
+  text = text.replace(/\[(CHAT|USER)=[^\]]+\][\s\S]*?\[\/\1\]/giu, (block: string) => {
+    bitrixEntityBlocks.push(block);
+    return `${PH_ENTITY}${bitrixEntityBlocks.length - 1}\x00`;
+  });
+
+  text = repairMalformedBitrixEntityMentions(text);
+
   // ── Phase 4: Restore placeholders ─────────────────────────────────────────
 
   // 4a. Horizontal rules → visual separator
@@ -205,7 +214,13 @@ export function markdownToBbCode(md: string): string {
     return value != null ? restoreBbCodeCodeBlock(value) : _m;
   });
 
-  // 4d. Escape sequences → literal characters
+  // 4d. Existing Bitrix entity mentions → original source, untouched
+  text = text.replace(new RegExp(`${PH_ENTITY.replace(/\x00/g, '\\x00')}(\\d+)\\x00`, 'g'), (_m, idx: string) => {
+    const value = bitrixEntityBlocks[Number(idx)];
+    return value != null ? value : _m;
+  });
+
+  // 4e. Escape sequences → literal characters
   text = text.replace(new RegExp(`${PH_ESC.replace(/\x00/g, '\\x00')}(\\d+)\\x00`, 'g'), (_m, idx: string) => {
     const value = escapes[Number(idx)];
     return value != null ? value : _m;
@@ -214,6 +229,44 @@ export function markdownToBbCode(md: string): string {
   return text;
 }
 
+function repairMalformedBitrixEntityMentions(text: string): string {
+  let repaired = text;
+
+  const quotedPatterns: RegExp[] = [
+    /\[(CHAT|USER)=([^\]]+)\]\s*«([^»\r\n]{1,80})»(?!\s*\[\/\1\])/giu,
+    /\[(CHAT|USER)=([^\]]+)\]\s*“([^”\r\n]{1,80})”(?!\s*\[\/\1\])/giu,
+    /\[(CHAT|USER)=([^\]]+)\]\s*"([^"\r\n]{1,80})"(?!\s*\[\/\1\])/giu,
+    /\[(CHAT|USER)=([^\]]+)\]\s*'([^'\r\n]{1,80})'(?!\s*\[\/\1\])/giu,
+  ];
+
+  for (const pattern of quotedPatterns) {
+    repaired = repaired.replace(pattern, (_match, rawTag: string, rawId: string, rawLabel: string) => {
+      return buildBitrixEntityMention(rawTag, rawId, rawLabel);
+    });
+  }
+
+  repaired = repaired.replace(
+    /\[(CHAT|USER)=([^\]]+)\]\s*([\p{Lu}\d][\p{L}\p{N}._+-]*(?:\s+[\p{Lu}\d][\p{L}\p{N}._+-]*){0,5})(?=$|[\s.,!?;:)\]]|\[)(?!\s*\[\/\1\])/gu,
+    (_match, rawTag: string, rawId: string, rawLabel: string) => {
+      return buildBitrixEntityMention(rawTag, rawId, rawLabel);
+    },
+  );
+
+  return repaired;
+}
+
+function buildBitrixEntityMention(rawTag: string, rawId: string, rawLabel: string): string {
+  const tag = rawTag.toUpperCase();
+  const id = rawId.trim();
+  const label = rawLabel.trim();
+
+  if (!id || !label) {
+    return `[${tag}=${rawId}]${rawLabel}`;
+  }
+
+  return `[${tag}=${id}]${label}[/${tag}]`;
+}
+
 function isInlineAccentToken(value: string): boolean {
   const trimmed = value.trim();
   if (!trimmed || /[\r\n\t]/.test(trimmed) || trimmed.length > 64) {

package/src/send-service.ts

@@ -209,12 +209,22 @@ export class SendService {
   /**
    * Send the default generic typing indicator.
    */
-  async sendTyping(ctx: SendContext): Promise<void> {
+  async sendTyping(ctx: SendContext, duration?: number): Promise<void> {
     try {
-      await this.api.notifyInputAction(ctx.webhookUrl, ctx.bot, ctx.dialogId);
+      if (duration === undefined) {
+        await this.api.notifyInputAction(ctx.webhookUrl, ctx.bot, ctx.dialogId);
+      } else {
+        await this.api.notifyInputAction(
+          ctx.webhookUrl,
+          ctx.bot,
+          ctx.dialogId,
+          { duration },
+        );
+      }
     } catch (error) {
       this.logger.debug('Failed to send typing indicator', {
         dialogId: ctx.dialogId,
+        duration,
         error: serializeError(error),
       });
     }