@ihazz/bitrix24 1.1.2 → 1.1.4

package/openclaw.plugin.json

@@ -5,6 +5,283 @@
   "configSchema": {
     "type": "object",
     "additionalProperties": true,
-    "properties": {}
+    "$defs": {
+      "watchRule": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "userId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "topics": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            }
+          },
+          "mode": {
+            "type": "string",
+            "enum": ["reply", "notifyOwnerDm"]
+          }
+        }
+      },
+      "agentWatchRule": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "userId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "topics": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            }
+          },
+          "mode": {
+            "type": "string",
+            "enum": ["notifyOwnerDm"]
+          }
+        }
+      },
+      "groupConfig": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "groupPolicy": {
+            "type": "string",
+            "enum": ["disabled", "webhookUser", "pairing", "allowlist", "open"]
+          },
+          "requireMention": {
+            "type": "boolean",
+            "default": true
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "watch": {
+            "type": "array",
+            "items": {
+              "$ref": "#/$defs/watchRule"
+            }
+          }
+        }
+      },
+      "accountConfig": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "default": true
+          },
+          "webhookUrl": {
+            "type": "string",
+            "pattern": "^https?://\\S+$"
+          },
+          "botToken": {
+            "type": "string"
+          },
+          "botName": {
+            "type": "string",
+            "default": "OpenClaw"
+          },
+          "botCode": {
+            "type": "string"
+          },
+          "botAvatar": {
+            "type": "string"
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "callbackUrl": {
+            "type": "string",
+            "pattern": "^https?://\\S+$"
+          },
+          "eventMode": {
+            "type": "string",
+            "enum": ["fetch", "webhook"]
+          },
+          "agentMode": {
+            "type": "boolean",
+            "default": false
+          },
+          "pollingIntervalMs": {
+            "type": "integer",
+            "minimum": 500,
+            "default": 3000
+          },
+          "pollingFastIntervalMs": {
+            "type": "integer",
+            "minimum": 50,
+            "default": 100
+          },
+          "dmPolicy": {
+            "type": "string",
+            "enum": ["pairing", "webhookUser", "allowlist", "open"],
+            "default": "webhookUser"
+          },
+          "groupPolicy": {
+            "type": "string",
+            "enum": ["disabled", "webhookUser", "pairing", "allowlist", "open"],
+            "default": "webhookUser"
+          },
+          "groupAllowFrom": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "requireMention": {
+            "type": "boolean",
+            "default": true
+          },
+          "historyLimit": {
+            "type": "integer",
+            "minimum": 0,
+            "default": 100
+          },
+          "groups": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/$defs/groupConfig"
+            }
+          },
+          "agentWatch": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "array",
+              "items": {
+                "$ref": "#/$defs/agentWatchRule"
+              }
+            }
+          },
+          "showTyping": {
+            "type": "boolean",
+            "default": true
+          },
+          "verboseLog": {
+            "type": "boolean",
+            "default": false
+          }
+        }
+      }
+    },
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "default": true
+      },
+      "webhookUrl": {
+        "type": "string",
+        "pattern": "^https?://\\S+$"
+      },
+      "botToken": {
+        "type": "string"
+      },
+      "botName": {
+        "type": "string",
+        "default": "OpenClaw"
+      },
+      "botCode": {
+        "type": "string"
+      },
+      "botAvatar": {
+        "type": "string"
+      },
+      "allowFrom": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "callbackUrl": {
+        "type": "string",
+        "pattern": "^https?://\\S+$"
+      },
+      "eventMode": {
+        "type": "string",
+        "enum": ["fetch", "webhook"]
+      },
+      "agentMode": {
+        "type": "boolean",
+        "default": false
+      },
+      "pollingIntervalMs": {
+        "type": "integer",
+        "minimum": 500,
+        "default": 3000
+      },
+      "pollingFastIntervalMs": {
+        "type": "integer",
+        "minimum": 50,
+        "default": 100
+      },
+      "dmPolicy": {
+        "type": "string",
+        "enum": ["pairing", "webhookUser", "allowlist", "open"],
+        "default": "webhookUser"
+      },
+      "groupPolicy": {
+        "type": "string",
+        "enum": ["disabled", "webhookUser", "pairing", "allowlist", "open"],
+        "default": "webhookUser"
+      },
+      "groupAllowFrom": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "requireMention": {
+        "type": "boolean",
+        "default": true
+      },
+      "historyLimit": {
+        "type": "integer",
+        "minimum": 0,
+        "default": 100
+      },
+      "groups": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#/$defs/groupConfig"
+        }
+      },
+      "agentWatch": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/agentWatchRule"
+          }
+        }
+      },
+      "showTyping": {
+        "type": "boolean",
+        "default": true
+      },
+      "verboseLog": {
+        "type": "boolean",
+        "default": false
+      },
+      "accounts": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#/$defs/accountConfig"
+        }
+      }
+    }
   }
 }

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@ihazz/bitrix24",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Bitrix24 Messenger channel for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
+    "dist",
     "index.ts",
     "openclaw.plugin.json",
     "README.md",
@@ -15,7 +23,7 @@
   ],
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./dist/index.js"
     ],
     "channel": {
       "id": "bitrix24",
@@ -33,6 +41,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepack": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest"
   },

package/src/api.ts

@@ -439,9 +439,6 @@ export class Bitrix24Api {
     return result.result;
   }
 
-  /**
-   * Backward-compatible wrapper for typing indicator.
-   */
   /**
    * Mark messages as read (imbot.v2.Chat.Message.read).
    */

package/src/channel.ts

@@ -9,7 +9,7 @@ import type { CommandSendContext, SendContext } from './send-service.js';
 import { MediaService } from './media-service.js';
 import type { DownloadedMedia } from './media-service.js';
 import { InboundHandler } from './inbound-handler.js';
-import type { FetchCommandContext, FetchJoinChatContext } from './inbound-handler.js';
+import type { FetchCommandContext, FetchJoinChatContext, FetchReactionContext } from './inbound-handler.js';
 import { PollingService } from './polling-service.js';
 import {
   normalizeAllowEntry,
@@ -24,7 +24,7 @@ import {
   resolveGroupAccess,
 } from './group-access.js';
 import { DEFAULT_AVATAR_BASE64 } from './bot-avatar.js';
-import { Bitrix24ApiError, defaultLogger, CHANNEL_PREFIX_RE } from './utils.js';
+import { Bitrix24ApiError, createVerboseLogger, defaultLogger, CHANNEL_PREFIX_RE } from './utils.js';
 import { getBitrix24Runtime } from './runtime.js';
 import type { ChannelPairingAdapter } from './runtime.js';
 import { OPENCLAW_COMMANDS, buildCommandsHelpText, formatModelsCommandReply } from './commands.js';
@@ -75,6 +75,7 @@ const HISTORY_CACHE_MAX_KEYS = 1000;
 const HISTORY_CONTEXT_MARKER = '[Chat messages since your last reply - for context]';
 const CROSS_CHAT_HISTORY_LIMIT = 20;
 const ACCESS_DENIED_REACTION = 'crossMark';
+const BOT_MESSAGE_WATCH_REACTION = 'eyes';
 const FORWARDED_CONTEXT_RANGE = 5;
 const REGISTERED_COMMANDS = new Set(OPENCLAW_COMMANDS.map((command) => command.command));
 
@@ -1407,19 +1408,16 @@ function collectOutboundMediaUrls(input: {
 }
 
 async function uploadOutboundMedia(params: {
-  sendCtx: SendContext;
+  mediaService: MediaService;
   mediaUrls: string[];
-  text?: string;
+  sendCtx: SendContext;
+  initialMessage?: string;
 }): Promise<string> {
-  if (!gatewayState) {
-    throw new Error('Bitrix24 gateway not started');
-  }
-
   let lastMessageId = '';
-  let message = params.text;
+  let message = params.initialMessage;
 
   for (const mediaUrl of params.mediaUrls) {
-    const result = await gatewayState.mediaService.uploadMediaToChat({
+    const result = await params.mediaService.uploadMediaToChat({
       localPath: mediaUrl,
       fileName: basename(mediaUrl),
       webhookUrl: params.sendCtx.webhookUrl,
@@ -1562,9 +1560,10 @@ export const bitrix24Plugin = {
       const mediaUrls = collectOutboundMediaUrls({ mediaUrl: ctx.mediaUrl });
       if (mediaUrls.length > 0) {
         const messageId = await uploadOutboundMedia({
+          mediaService: gatewayState.mediaService,
           sendCtx,
           mediaUrls,
-          text: ctx.text,
+          initialMessage: ctx.text,
         });
         return { messageId };
       }
@@ -1598,6 +1597,7 @@ export const bitrix24Plugin = {
 
       if (mediaUrls.length > 0) {
         const uploadedMessageId = await uploadOutboundMedia({
+          mediaService: gatewayState.mediaService,
           sendCtx,
           mediaUrls,
         });
@@ -1645,6 +1645,12 @@ export const bitrix24Plugin = {
       params: Record<string, unknown>;
       [key: string]: unknown;
     }): Promise<Record<string, unknown> | null> => {
+      // Helper: wrap payload as gateway-compatible tool result
+      const toolResult = (payload: Record<string, unknown>) => ({
+        content: [{ type: 'text' as const, text: JSON.stringify(payload, null, 2) }],
+        details: payload,
+      });
+
       // ─── Send with buttons ──────────────────────────────────────────────
       if (ctx.action === 'send') {
         // Only intercept send when buttons are present; otherwise let gateway handle normally
@@ -1675,11 +1681,6 @@ export const bitrix24Plugin = {
 
         const keyboard = buttons?.length ? convertButtonsToKeyboard(buttons) : undefined;
 
-        const toolResult = (payload: Record<string, unknown>) => ({
-          content: [{ type: 'text' as const, text: JSON.stringify(payload, null, 2) }],
-          details: payload,
-        });
-
         try {
           const result = await gatewayState.sendService.sendText(
             sendCtx, message || ' ', keyboard ? { keyboard } : undefined,
@@ -1700,12 +1701,6 @@ export const bitrix24Plugin = {
       // ─── React ────────────────────────────────────────────────────────────
       if (ctx.action !== 'react') return null;
 
-      // Helper: wrap payload as gateway-compatible tool result
-      const toolResult = (payload: Record<string, unknown>) => ({
-        content: [{ type: 'text' as const, text: JSON.stringify(payload, null, 2) }],
-        details: payload,
-      });
-
       const { config } = resolveAccount(ctx.cfg, ctx.accountId);
       if (!config.webhookUrl || !gatewayState) {
         return toolResult({ ok: false, reason: 'not_started', hint: 'Bitrix24 gateway not started. Do not retry.' });
@@ -1782,8 +1777,6 @@ export const bitrix24Plugin = {
       log?: Logger;
       setStatus?: (status: Record<string, unknown>) => void;
     }) => {
-      const logger = ctx.log ?? defaultLogger;
-
       // Guard: only one account can run at a time (singleton gateway)
       if (gatewayState !== null) {
         throw new Error(
@@ -1793,6 +1786,7 @@ export const bitrix24Plugin = {
       }
 
       const config = getConfig(ctx.cfg, ctx.accountId);
+      const logger = createVerboseLogger(ctx.log ?? defaultLogger, Boolean(config.verboseLog));
 
       if (!config.webhookUrl) {
         logger.warn(`[${ctx.accountId}] no webhookUrl configured, skipping`);
@@ -2114,18 +2108,12 @@ export const bitrix24Plugin = {
                 deliver: async (payload) => {
                   await replyStatusHeartbeat.stopAndWait();
                   const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
-                  for (const mediaUrl of mediaUrls) {
-                    const uploadResult = await mediaService.uploadMediaToChat({
-                      localPath: mediaUrl,
-                      fileName: basename(mediaUrl),
-                      webhookUrl,
-                      bot,
-                      dialogId: conversation.dialogId,
+                  if (mediaUrls.length > 0) {
+                    await uploadOutboundMedia({
+                      mediaService,
+                      sendCtx,
+                      mediaUrls,
                     });
-
-                    if (!uploadResult.ok) {
-                      throw new Error(`Failed to upload media: ${basename(mediaUrl)}`);
-                    }
                   }
                   if (payload.text) {
                     let text = payload.text;
@@ -2209,6 +2197,45 @@ export const bitrix24Plugin = {
           });
         }
       };
+      const maybeReactToBotMessageReaction = async (reactionCtx: FetchReactionContext): Promise<void> => {
+        if (reactionCtx.action !== 'set') {
+          return;
+        }
+
+        const botId = String(bot.botId);
+        if (reactionCtx.senderId === botId || reactionCtx.messageAuthorId !== botId) {
+          return;
+        }
+
+        const messageId = toMessageId(reactionCtx.messageId);
+        if (!messageId) {
+          return;
+        }
+
+        try {
+          await api.addReaction(
+            webhookUrl,
+            bot,
+            messageId,
+            BOT_MESSAGE_WATCH_REACTION,
+          );
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes('REACTION_ALREADY_SET')) {
+            logger.debug('Watch reaction already set on bot message', {
+              chatId: reactionCtx.dialogId,
+              messageId: reactionCtx.messageId,
+            });
+            return;
+          }
+
+          logger.warn('Failed to add watch reaction to bot message', {
+            chatId: reactionCtx.dialogId,
+            messageId: reactionCtx.messageId,
+            error: err,
+          });
+        }
+      };
       const notifyWebhookOwnerAboutWatchMatch = async (
         msgCtx: B24MsgContext,
         watchRule: Bitrix24GroupWatchConfig | Bitrix24AgentWatchConfig,
@@ -2295,6 +2322,9 @@ export const bitrix24Plugin = {
       const inboundHandler = new InboundHandler({
         config,
         logger,
+        onReactionChange: async (reactionCtx) => {
+          await maybeReactToBotMessageReaction(reactionCtx);
+        },
 
         onMessage: async (msgCtx: B24MsgContext) => {
           logger.info('Inbound message', {
@@ -2349,6 +2379,10 @@ export const bitrix24Plugin = {
             ? findMatchingWatchRule(msgCtx, agentWatchRules)
             : undefined;
 
+          /** Shorthand: record message in RAM history for this dialog. */
+          const recordHistory = (body?: string) =>
+            appendMessageToHistory({ historyCache, historyKey, historyLimit, msgCtx, body });
+
           if (msgCtx.eventScope === 'user') {
             const isBotDialogUserEvent = msgCtx.isDm && msgCtx.chatId === String(bot.botId);
             const isBotAuthoredUserEvent = msgCtx.senderId === String(bot.botId);
@@ -2364,12 +2398,7 @@ export const bitrix24Plugin = {
               return;
             }
 
-            appendMessageToHistory({
-              historyCache,
-              historyKey,
-              historyLimit,
-              msgCtx,
-            });
+            recordHistory();
 
             if (webhookOwnerId && msgCtx.senderId !== webhookOwnerId && agentWatchRule?.mode === 'notifyOwnerDm') {
               await notifyWebhookOwnerAboutWatchMatch(msgCtx, agentWatchRule);
@@ -2405,12 +2434,7 @@ export const bitrix24Plugin = {
             && groupAccess?.requireMention
             && !msgCtx.wasMentioned
           ) {
-            appendMessageToHistory({
-              historyCache,
-              historyKey,
-              historyLimit,
-              msgCtx,
-            });
+            recordHistory();
 
             logger.info('Skipping group message without mention', {
               chatId: msgCtx.chatId,
@@ -2421,12 +2445,7 @@ export const bitrix24Plugin = {
           }
 
           if (activeWatchRule?.mode === 'notifyOwnerDm') {
-            appendMessageToHistory({
-              historyCache,
-              historyKey,
-              historyLimit,
-              msgCtx,
-            });
+            recordHistory();
 
             await notifyWebhookOwnerAboutWatchMatch(msgCtx, activeWatchRule);
             logger.debug('Group watch matched and notified webhook owner in DM', {
@@ -2466,12 +2485,7 @@ export const bitrix24Plugin = {
 
           if (accessResult === 'deny') {
             if (msgCtx.isGroup) {
-              appendMessageToHistory({
-                historyCache,
-                historyKey,
-                historyLimit,
-                msgCtx,
-              });
+              recordHistory();
 
               if (!msgCtx.wasMentioned) {
                 logger.debug('Group message blocked silently without mention', {
@@ -2507,12 +2521,7 @@ export const bitrix24Plugin = {
 
           if (accessResult === 'pairing') {
             if (msgCtx.isGroup) {
-              appendMessageToHistory({
-                historyCache,
-                historyKey,
-                historyLimit,
-                msgCtx,
-              });
+              recordHistory();
 
               await maybeSendDialogNotice(
                 `group-pairing:${msgCtx.chatId}:${msgCtx.senderId}`,
@@ -2659,8 +2668,6 @@ export const bitrix24Plugin = {
             logger.warn('Command event has invalid messageId, skipping response', { commandId, messageId, dialogId });
             return;
           }
-          const canMarkRead = true;
-
           if (!isDm && groupAccess?.groupPolicy === 'disabled') {
             await sendService.answerCommandText(
               commandSendCtx,
@@ -2673,9 +2680,7 @@ export const bitrix24Plugin = {
           await sendService.sendStatus(sendCtx, 'IMBOT_AGENT_ACTION_THINKING', 8);
 
           if (accessResult === 'deny') {
-            if (canMarkRead) {
-              await sendService.markRead(sendCtx, commandMessageId);
-            }
+            await sendService.markRead(sendCtx, commandMessageId);
             await sendService.answerCommandText(
               commandSendCtx,
               buildAccessDeniedNotice(
@@ -2693,9 +2698,7 @@ export const bitrix24Plugin = {
             return;
           }
 
-          if (canMarkRead) {
-            await sendService.markRead(sendCtx, commandMessageId);
-          }
+          await sendService.markRead(sendCtx, commandMessageId);
 
           if (accessResult === 'pairing') {
             if (!isDm) {

package/src/config-schema.ts

@@ -38,8 +38,7 @@ const AccountSchema = z.object({
   groups: z.record(z.string(), GroupSchema).optional(),
   agentWatch: z.record(z.string(), z.array(AgentWatchRuleSchema)).optional(),
   showTyping: z.boolean().optional().default(true),
-  streamUpdates: z.boolean().optional().default(false),
-  updateIntervalMs: z.number().int().min(500).optional().default(10000),
+  verboseLog: z.boolean().optional().default(false),
 });
 
 export const Bitrix24ConfigSchema = AccountSchema.extend({

package/src/config.ts

@@ -54,16 +54,14 @@ export function resolveAccount(
   let config = getConfig(cfg, id);
 
   // Validate and normalize config against Zod schema.
-  if (config.webhookUrl) {
-    const result = Bitrix24ConfigSchema.safeParse(config);
-    if (!result.success) {
-      const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
-      throw new Error(`[bitrix24] Invalid config for account "${id}": ${issues}`);
-    }
-
-    config = result.data;
+  const result = Bitrix24ConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
+    throw new Error(`[bitrix24] Invalid config for account "${id}": ${issues}`);
   }
 
+  config = result.data;
+
   return {
     accountId: id,
     config,

package/src/group-access.ts

@@ -37,14 +37,7 @@ function normalizeWatchRules<T extends { userId: string; topics?: string[]; mode
 }
 
 export function normalizeGroupEntry(entry: string): string {
-  const normalized = String(entry).trim().toLowerCase();
-  if (/^\d+$/.test(normalized)) {
-    return normalized;
-  }
-  if (/^chat\d+$/.test(normalized)) {
-    return normalized;
-  }
-  return normalized;
+  return String(entry).trim().toLowerCase();
 }
 
 export function normalizeGroupAllowList(entries: string[] | undefined): string[] {