@ihazz/bitrix24 0.2.4 → 0.2.5

package/README.md

@@ -74,9 +74,9 @@ Only `webhookUrl` is required. The gateway will not start without it.
 | Parameter | Default | Description |
 |---|---|---|
 | `webhookUrl` | — | Bitrix24 REST webhook URL (**required**) |
+| `callbackUrl` | — | Full public URL for bot EVENT_HANDLER (e.g. `https://your-server.com/hooks/bitrix24`). Path is auto-extracted for route registration. (**required**) |
 | `botName` | `"OpenClaw"` | Bot display name (shown in welcome message) |
 | `botCode` | `"openclaw"` | Unique bot code for `imbot.register` |
-| `callbackUrl` | — | Full public URL for bot EVENT_HANDLER (e.g. `https://your-server.com/hooks/bitrix24`). Path is auto-extracted for route registration. |
 | `dmPolicy` | `"open"` | Access policy: `"open"` / `"allowlist"` / `"pairing"` |
 | `allowFrom` | — | Allowed B24 user IDs (when `dmPolicy: "allowlist"`) |
 | `showTyping` | `true` | Send typing indicator before responding |
@@ -160,10 +160,10 @@ ngrok http 3000
 
 Use the HTTPS URL from ngrok as the event handler URL in Bitrix24 bot settings.
 
-## Running
+## Running (restarting)
 
 ```bash
-openclaw start
+systemctl restart openclaw
 ```
 
 On successful start, logs will show: `Bitrix24 gateway started, webhook at /hooks/bitrix24`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ihazz/bitrix24",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Bitrix24 Messenger channel for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",

package/src/access-control.ts

@@ -89,7 +89,9 @@ export async function checkAccessWithPairing(params: {
       channel: 'bitrix24',
       accountId,
     });
-    await sendReply(reply.text);
+    // buildPairingReply returns a string directly, not an object
+    const replyText = typeof reply === 'string' ? reply : (reply as { text?: string })?.text ?? String(reply);
+    await sendReply(replyText);
   }
 
   logger?.debug('Pairing request handled', { senderId, code, created });

package/src/channel.ts

@@ -294,6 +294,25 @@ export async function handleWebhookRequest(req: IncomingMessage, res: ServerResp
   }
 }
 
+// ─── Outbound adapter helpers ────────────────────────────────────────────────
+
+/**
+ * Build a minimal SendContext from the delivery pipeline's outbound context.
+ * The pipeline provides `cfg` (full OpenClaw config) and `to` (normalized dialog ID).
+ * We resolve the account config to get `webhookUrl`.
+ */
+function resolveOutboundSendCtx(params: {
+  cfg: Record<string, unknown>;
+  to: string;
+  accountId?: string;
+}): { webhookUrl?: string; dialogId: string } {
+  const { config } = resolveAccount(params.cfg, params.accountId);
+  return {
+    webhookUrl: config.webhookUrl,
+    dialogId: params.to,
+  };
+}
+
 /**
  * The Bitrix24 channel plugin object.
  *
@@ -322,6 +341,11 @@ export const bitrix24Plugin = {
   },
 
   messaging: {
+    /**
+     * Normalize target ID by stripping the channel prefix.
+     * Called by the delivery pipeline so that `to` in outbound context is a clean numeric ID.
+     */
+    normalizeTarget: (raw: string) => raw.trim().replace(/^(bitrix24|b24|bx24):/i, ''),
     targetResolver: {
       hint: 'Use a numeric chat/dialog ID, e.g. "1" or "chat42".',
       /**
@@ -372,94 +396,87 @@ export const bitrix24Plugin = {
 
   outbound: {
     deliveryMode: 'direct' as const,
+    textChunkLimit: 4000,
 
     /**
      * Send a text message to B24 via the bot.
-     * Called by OpenClaw when the agent produces a response.
+     * Called by the OpenClaw delivery pipeline (message tool path).
+     *
+     * Context shape: { cfg, to, accountId, text, replyToId?, threadId?, ... }
      */
-    sendText: async (params: {
+    sendText: async (ctx: {
+      cfg: Record<string, unknown>;
+      to: string;
+      accountId?: string;
       text: string;
-      context: B24MsgContext;
-      account: { config: { webhookUrl?: string; showTyping?: boolean } };
+      [key: string]: unknown;
     }) => {
-      const { text, 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);
-      }
-
-      // Send the response
-      const result = await sendService.sendText(sendCtx, text);
-
-      return {
-        ok: result.ok,
-        messageId: result.messageId,
-        channel: 'bitrix24' as const,
-        error: result.error,
-      };
+      if (!gatewayState) throw new Error('Bitrix24 gateway not started');
+      const sendCtx = resolveOutboundSendCtx(ctx);
+      const result = await gatewayState.sendService.sendText(sendCtx, ctx.text);
+      return { messageId: String(result.messageId ?? '') };
     },
 
     /**
-     * Send a payload with optional channelData (keyboards, etc.) to B24.
-     * Called by OpenClaw when the response includes channelData.
+     * Send a media message to B24.
+     * Called by the delivery pipeline when the agent sends media.
+     *
+     * Note: full media upload requires OAuth bot token (clientEndpoint + botToken)
+     * which is only available in the reply path (inbound webhook events).
+     * In the message tool path we only have the webhook URL, so we send the caption text.
      */
-    sendPayload: async (params: {
+    sendMedia: async (ctx: {
+      cfg: Record<string, unknown>;
+      to: string;
+      accountId?: string;
       text: string;
-      channelData?: Record<string, unknown>;
-      context: B24MsgContext;
-      account: { config: { webhookUrl?: string; showTyping?: boolean } };
+      mediaUrl?: string;
+      [key: string]: unknown;
     }) => {
-      const { text, channelData, context, account } = params;
-
-      if (!gatewayState) {
-        return { ok: false, error: 'Gateway not started', channel: 'bitrix24' };
+      if (!gatewayState) throw new Error('Bitrix24 gateway not started');
+      const sendCtx = resolveOutboundSendCtx(ctx);
+      // Media upload via message tool path not supported (no OAuth token).
+      // Send caption text only.
+      if (ctx.text) {
+        const result = await gatewayState.sendService.sendText(sendCtx, ctx.text);
+        return { messageId: String(result.messageId ?? '') };
       }
+      return { messageId: '' };
+    },
 
-      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);
-      }
+    /**
+     * Send a rich payload with optional channelData (keyboards, etc.) to B24.
+     * Called by the delivery pipeline when payload includes channelData.
+     *
+     * Context shape: { cfg, to, accountId, text, mediaUrl?, payload, ... }
+     */
+    sendPayload: async (ctx: {
+      cfg: Record<string, unknown>;
+      to: string;
+      accountId?: string;
+      text: string;
+      mediaUrl?: string;
+      payload?: { channelData?: Record<string, unknown>; [key: string]: unknown };
+      [key: string]: unknown;
+    }) => {
+      if (!gatewayState) throw new Error('Bitrix24 gateway not started');
+      const sendCtx = resolveOutboundSendCtx(ctx);
 
       // Extract keyboard from channelData
-      const keyboard = channelData
-        ? extractKeyboardFromPayload({ channelData })
+      const keyboard = ctx.payload?.channelData
+        ? extractKeyboardFromPayload({ channelData: ctx.payload.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,
-      };
+      // Send text + keyboard
+      if (ctx.text) {
+        const result = await gatewayState.sendService.sendText(
+          sendCtx,
+          ctx.text,
+          keyboard ? { keyboard } : undefined,
+        );
+        return { messageId: String(result.messageId ?? '') };
+      }
+      return { messageId: '' };
     },
   },
 

package/tests/channel.test.ts

@@ -415,67 +415,64 @@ describe('bitrix24Plugin', () => {
     });
   });
 
+  describe('messaging', () => {
+    it('normalizeTarget strips bitrix24: prefix', () => {
+      expect(bitrix24Plugin.messaging.normalizeTarget('bitrix24:1')).toBe('1');
+      expect(bitrix24Plugin.messaging.normalizeTarget('b24:42')).toBe('42');
+      expect(bitrix24Plugin.messaging.normalizeTarget('bx24:100')).toBe('100');
+      expect(bitrix24Plugin.messaging.normalizeTarget('123')).toBe('123');
+      expect(bitrix24Plugin.messaging.normalizeTarget('  bitrix24:5  ')).toBe('5');
+    });
+
+    it('looksLikeId recognizes numeric IDs', () => {
+      expect(bitrix24Plugin.messaging.targetResolver.looksLikeId('bitrix24:1', '1')).toBe(true);
+      expect(bitrix24Plugin.messaging.targetResolver.looksLikeId('42', '42')).toBe(true);
+      expect(bitrix24Plugin.messaging.targetResolver.looksLikeId('abc', 'abc')).toBe(false);
+    });
+  });
+
   describe('outbound', () => {
     it('has direct delivery mode', () => {
       expect(bitrix24Plugin.outbound.deliveryMode).toBe('direct');
     });
 
-    it('sendText returns error when gateway not started', async () => {
-      const result = await bitrix24Plugin.outbound.sendText({
-        text: 'Hello',
-        context: {
-          channel: 'bitrix24',
-          senderId: '1',
-          senderName: 'Test',
-          chatId: '1',
-          chatInternalId: '100',
-          messageId: '1',
-          text: 'Hello',
-          isDm: true,
-          isGroup: false,
-          media: [],
-          raw: {} as any,
-          botToken: 'token',
-          userToken: 'utoken',
-          clientEndpoint: 'https://test.bitrix24.com/rest/',
-          botId: 1,
-          memberId: 'mem1',
-        },
-        account: { config: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } },
-      });
+    it('has textChunkLimit of 4000', () => {
+      expect(bitrix24Plugin.outbound.textChunkLimit).toBe(4000);
+    });
 
-      expect(result.ok).toBe(false);
-      expect(result.error).toBe('Gateway not started');
-      expect(result.channel).toBe('bitrix24');
+    it('sendText throws when gateway not started', async () => {
+      await expect(
+        bitrix24Plugin.outbound.sendText({
+          cfg: { channels: { bitrix24: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } } },
+          to: '1',
+          accountId: 'default',
+          text: 'Hello',
+        }),
+      ).rejects.toThrow('Bitrix24 gateway not started');
     });
 
-    it('sendPayload returns error when gateway not started', async () => {
-      const result = await bitrix24Plugin.outbound.sendPayload({
-        text: 'Hello',
-        channelData: { telegram: { buttons: [[{ text: 'OK' }]] } },
-        context: {
-          channel: 'bitrix24',
-          senderId: '1',
-          senderName: 'Test',
-          chatId: '1',
-          chatInternalId: '100',
-          messageId: '1',
+    it('sendMedia throws when gateway not started', async () => {
+      await expect(
+        bitrix24Plugin.outbound.sendMedia({
+          cfg: { channels: { bitrix24: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } } },
+          to: '1',
+          accountId: 'default',
           text: 'Hello',
-          isDm: true,
-          isGroup: false,
-          media: [],
-          raw: {} as any,
-          botToken: 'token',
-          userToken: 'utoken',
-          clientEndpoint: 'https://test.bitrix24.com/rest/',
-          botId: 1,
-          memberId: 'mem1',
-        },
-        account: { config: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } },
-      });
+          mediaUrl: '/tmp/test.jpg',
+        }),
+      ).rejects.toThrow('Bitrix24 gateway not started');
+    });
 
-      expect(result.ok).toBe(false);
-      expect(result.error).toBe('Gateway not started');
+    it('sendPayload throws when gateway not started', async () => {
+      await expect(
+        bitrix24Plugin.outbound.sendPayload({
+          cfg: { channels: { bitrix24: { webhookUrl: 'https://test.bitrix24.com/rest/1/token/' } } },
+          to: '1',
+          accountId: 'default',
+          text: 'Hello',
+          payload: { channelData: { telegram: { buttons: [[{ text: 'OK' }]] } } },
+        }),
+      ).rejects.toThrow('Bitrix24 gateway not started');
     });
   });