@ihazz/bitrix24 1.1.12 → 1.1.14

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,126 @@ 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 {};
+  }
+
+  if (Array.isArray(rawFiles)) {
+    return rawFiles.reduce<Record<string, Record<string, unknown>>>((acc, item) => {
+      if (!item || typeof item !== 'object') {
+        return acc;
+      }
+
+      const normalizedItem = item as Record<string, unknown>;
+      const rawId = normalizedItem.id ?? normalizedItem.ID;
+      if (rawId == null) {
+        return acc;
+      }
+
+      acc[String(rawId)] = normalizedItem;
+      return acc;
+    }, {});
+  }
+
+  return rawFiles as Record<string, Record<string, unknown>>;
+}
+
+function normalizeFileExtension(rawExtension: unknown, fileName?: string): string {
+  const explicitExtension = typeof rawExtension === 'string'
+    ? rawExtension.trim().replace(/^\.+/, '')
+    : '';
+  if (explicitExtension) {
+    return explicitExtension;
+  }
+
+  const normalizedName = typeof fileName === 'string' ? fileName.trim() : '';
+  const lastDotIndex = normalizedName.lastIndexOf('.');
+  if (lastDotIndex <= 0 || lastDotIndex === normalizedName.length - 1) {
+    return '';
+  }
+
+  return normalizedName.slice(lastDotIndex + 1).trim().replace(/^\.+/, '');
+}
+
+function normalizeFileName(params: {
+  fileId: string;
+  rawName: unknown;
+  rawExtension: unknown;
+}): string {
+  const normalizedName = typeof params.rawName === 'string'
+    ? params.rawName.trim()
+    : '';
+  if (normalizedName) {
+    return normalizedName;
+  }
+
+  const extension = normalizeFileExtension(params.rawExtension);
+  return extension ? `file_${params.fileId}.${extension}` : `file_${params.fileId}`;
+}
+
+function normalizeMediaType(rawType: unknown, extension: string): 'image' | 'file' {
+  const normalizedType = typeof rawType === 'string'
+    ? rawType.trim().toLowerCase()
+    : '';
+
+  if (normalizedType === 'image') {
+    return 'image';
+  }
+
+  if (['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'svg', 'tiff', 'tif', 'ico'].includes(
+    extension.toLowerCase(),
+  )) {
+    return 'image';
+  }
+
+  return 'file';
+}
+
 function extractFilesFromParams(params: B24V2MessageParams | undefined): B24MediaItem[] {
   const normalizedParams = normalizeMessageParams(params);
 
@@ -475,13 +788,40 @@ function extractFilesFromParams(params: B24V2MessageParams | undefined): B24Medi
   const fileIds = Array.isArray(rawFileIds) ? rawFileIds : [rawFileIds];
   if (!fileIds.length) return [];
 
-  return fileIds.map((id) => ({
-    id: String(id),
-    name: `file_${id}`,
-    extension: '',
-    size: 0,
-    type: 'file' as const,
-  }));
+  const fileRecords = normalizeFileRecords(normalizedParams.FILES);
+
+  return fileIds.map((id) => {
+    const fileId = String(id);
+    const fileRecord = fileRecords[fileId] ?? {};
+    const viewerAttrs = fileRecord.viewerAttrs;
+    const viewerTitle = viewerAttrs && typeof viewerAttrs === 'object'
+      ? (viewerAttrs as Record<string, unknown>).title
+      : undefined;
+    const rawName = fileRecord.name ?? fileRecord.NAME ?? viewerTitle;
+    const name = normalizeFileName({
+      fileId,
+      rawName,
+      rawExtension: fileRecord.extension ?? fileRecord.EXTENSION,
+    });
+    const extension = normalizeFileExtension(
+      fileRecord.extension ?? fileRecord.EXTENSION,
+      name,
+    );
+    const rawSize = Number(fileRecord.size ?? fileRecord.SIZE ?? 0);
+    const size = Number.isFinite(rawSize) && rawSize > 0 ? rawSize : 0;
+    const urlDownload = typeof fileRecord.urlDownload === 'string'
+      ? fileRecord.urlDownload
+      : undefined;
+
+    return {
+      id: fileId,
+      name,
+      extension,
+      size,
+      type: normalizeMediaType(fileRecord.type ?? fileRecord.TYPE, extension),
+      ...(urlDownload ? { urlDownload } : {}),
+    };
+  });
 }
 
 function extractReplyToMessageId(params: B24V2MessageParams | undefined): string | undefined {