opc-agent 4.1.2 → 4.1.3

package/tests/channels/email.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { EmailChannel } from '../../src/channels/email';
-
-describe('EmailChannel', () => {
-  // ── Webhook Payload Parsing ──────────────────────
-
-  describe('parseWebhookPayload', () => {
-    it('should parse standard payload', () => {
-      const payload = {
-        from: 'alice@example.com',
-        to: ['bob@example.com'],
-        subject: 'Test Email',
-        body: 'Hello from email',
-        messageId: '<msg123@example.com>',
-        date: '2026-01-15T10:00:00Z',
-      };
-
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email).not.toBeNull();
-      expect(email!.from).toBe('alice@example.com');
-      expect(email!.to).toEqual(['bob@example.com']);
-      expect(email!.subject).toBe('Test Email');
-      expect(email!.body).toBe('Hello from email');
-      expect(email!.messageId).toBe('<msg123@example.com>');
-    });
-
-    it('should parse SendGrid-style payload', () => {
-      const payload = {
-        from: 'sender@test.com',
-        to: 'recipient@test.com',
-        subject: 'SG Test',
-        text: 'Body from SendGrid',
-        html: '<p>Body from SendGrid</p>',
-      };
-
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email).not.toBeNull();
-      expect(email!.body).toBe('Body from SendGrid');
-      expect(email!.html).toBe('<p>Body from SendGrid</p>');
-      expect(email!.to).toEqual(['recipient@test.com']);
-    });
-
-    it('should parse Mailgun-style payload', () => {
-      const payload = {
-        sender: 'mg@example.com',
-        recipient: 'user@example.com',
-        subject: 'MG Test',
-        'body-plain': 'Plain text body',
-        'body-html': '<p>HTML body</p>',
-        'Message-Id': '<mg123@mailgun>',
-      };
-
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email).not.toBeNull();
-      expect(email!.from).toBe('mg@example.com');
-      expect(email!.body).toBe('Plain text body');
-      expect(email!.messageId).toBe('<mg123@mailgun>');
-    });
-
-    it('should return null for payload without from', () => {
-      const email = EmailChannel.parseWebhookPayload({ subject: 'No sender' });
-      expect(email).toBeNull();
-    });
-
-    it('should handle envelope format', () => {
-      const payload = {
-        envelope: { from: 'env@test.com', to: ['a@b.com'] },
-        subject: 'Envelope test',
-        body: 'content',
-      };
-
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email).not.toBeNull();
-      expect(email!.from).toBe('env@test.com');
-    });
-
-    it('should generate messageId if missing', () => {
-      const payload = { from: 'a@b.com', body: 'test' };
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email).not.toBeNull();
-      expect(email!.messageId).toMatch(/^email-/);
-    });
-
-    it('should handle inReplyTo and references', () => {
-      const payload = {
-        from: 'a@b.com',
-        body: 'reply',
-        inReplyTo: '<orig@b.com>',
-        references: ['<orig@b.com>', '<prev@b.com>'],
-      };
-
-      const email = EmailChannel.parseWebhookPayload(payload);
-      expect(email!.inReplyTo).toBe('<orig@b.com>');
-      expect(email!.references).toEqual(['<orig@b.com>', '<prev@b.com>']);
-    });
-  });
-
-  // ── Filter Matching ──────────────────────────────
-
-  describe('matchesFilters', () => {
-    it('should match all when no filters', () => {
-      const channel = new EmailChannel({ mode: 'webhook' });
-      const result = channel.matchesFilters({
-        messageId: 'x', from: 'a@b.com', to: [], subject: 'test', body: '', date: new Date(),
-      });
-      expect(result).toBe(true);
-    });
-
-    it('should filter by from address', () => {
-      const channel = new EmailChannel({
-        mode: 'webhook',
-        filters: { from: ['allowed@example.com'] },
-      });
-
-      expect(channel.matchesFilters({
-        messageId: 'x', from: 'allowed@example.com', to: [], subject: '', body: '', date: new Date(),
-      })).toBe(true);
-
-      expect(channel.matchesFilters({
-        messageId: 'x', from: 'blocked@other.com', to: [], subject: '', body: '', date: new Date(),
-      })).toBe(false);
-    });
-
-    it('should filter by subject', () => {
-      const channel = new EmailChannel({
-        mode: 'webhook',
-        filters: { subject: ['[SUPPORT]'] },
-      });
-
-      expect(channel.matchesFilters({
-        messageId: 'x', from: 'a@b.com', to: [], subject: '[SUPPORT] Help me', body: '', date: new Date(),
-      })).toBe(true);
-
-      expect(channel.matchesFilters({
-        messageId: 'x', from: 'a@b.com', to: [], subject: 'Random email', body: '', date: new Date(),
-      })).toBe(false);
-    });
-  });
-
-  // ── Constructor ──────────────────────────────────
-
-  describe('constructor', () => {
-    it('should create with webhook mode', () => {
-      const channel = new EmailChannel({ mode: 'webhook', webhookPort: 9090 });
-      expect(channel.type).toBe('email');
-    });
-  });
-});

package/tests/channels/feishu.test.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { FeishuChannel } from '../../src/channels/feishu';
-
-describe('FeishuChannel', () => {
-  // ── Event Parsing ────────────────────────────────
-
-  describe('parseEventBody', () => {
-    it('should parse url_verification challenge', () => {
-      const body = { type: 'url_verification', challenge: 'abc123' };
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.type).toBe('url_verification');
-      expect(result.challenge).toBe('abc123');
-    });
-
-    it('should parse text message event', () => {
-      const body = {
-        header: {
-          event_id: 'evt_123',
-          event_type: 'im.message.receive_v1',
-          token: 'tok',
-        },
-        event: {
-          message: {
-            message_id: 'msg_123',
-            chat_id: 'oc_456',
-            message_type: 'text',
-            content: JSON.stringify({ text: 'Hello Feishu' }),
-            create_time: '1699999999',
-            chat_type: 'p2p',
-          },
-          sender: {
-            sender_id: { open_id: 'ou_789' },
-          },
-        },
-      };
-
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.type).toBe('message');
-      expect(result.content).toBe('Hello Feishu');
-      expect(result.chatId).toBe('oc_456');
-      expect(result.senderId).toBe('ou_789');
-      expect(result.messageId).toBe('msg_123');
-    });
-
-    it('should strip @bot mentions from content', () => {
-      const body = {
-        header: { event_type: 'im.message.receive_v1' },
-        event: {
-          message: {
-            message_id: 'msg_1',
-            chat_id: 'oc_1',
-            message_type: 'text',
-            content: JSON.stringify({ text: '@_user_123 Hello bot' }),
-          },
-          sender: { sender_id: { open_id: 'ou_1' } },
-        },
-      };
-
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.content).toBe('Hello bot');
-    });
-
-    it('should return empty content for non-text messages', () => {
-      const body = {
-        header: { event_type: 'im.message.receive_v1' },
-        event: {
-          message: {
-            message_id: 'msg_1',
-            chat_id: 'oc_1',
-            message_type: 'image',
-            content: '{}',
-          },
-          sender: { sender_id: { open_id: 'ou_1' } },
-        },
-      };
-
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.content).toBe('');
-    });
-
-    it('should handle unknown event types', () => {
-      const body = { header: { event_type: 'some.other.event' }, event: {} };
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.type).toBe('unknown');
-    });
-
-    it('should handle malformed content JSON gracefully', () => {
-      const body = {
-        header: { event_type: 'im.message.receive_v1' },
-        event: {
-          message: {
-            message_id: 'msg_1',
-            chat_id: 'oc_1',
-            message_type: 'text',
-            content: 'not-json',
-          },
-          sender: { sender_id: { open_id: 'ou_1' } },
-        },
-      };
-
-      const result = FeishuChannel.parseEventBody(body);
-      expect(result.content).toBe('not-json');
-    });
-  });
-
-  // ── Constructor ──────────────────────────────────
-
-  describe('constructor', () => {
-    it('should use defaults', () => {
-      const channel = new FeishuChannel();
-      expect(channel.type).toBe('feishu');
-    });
-
-    it('should accept config', () => {
-      const channel = new FeishuChannel({
-        appId: 'myapp',
-        appSecret: 'secret',
-        port: 9999,
-      });
-      expect(channel.type).toBe('feishu');
-    });
-  });
-});

package/tests/channels/telegram.test.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { TelegramChannel } from '../../src/channels/telegram';
-
-describe('TelegramChannel', () => {
-  it('constructor sets token from config', () => {
-    const ch = new TelegramChannel({ token: 'test-token-123' });
-    expect((ch as any).token).toBe('test-token-123');
-  });
-
-  it('constructor defaults to polling mode', () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    expect((ch as any).mode).toBe('polling');
-  });
-
-  it('constructor reads token from env var', () => {
-    const orig = process.env.TELEGRAM_BOT_TOKEN;
-    process.env.TELEGRAM_BOT_TOKEN = 'env-token';
-    const ch = new TelegramChannel({});
-    expect((ch as any).token).toBe('env-token');
-    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
-    else delete process.env.TELEGRAM_BOT_TOKEN;
-  });
-
-  it('constructor sets webhook mode', () => {
-    const ch = new TelegramChannel({ token: 'tok', mode: 'webhook', webhookUrl: 'https://x.com' });
-    expect((ch as any).mode).toBe('webhook');
-    expect((ch as any).webhookUrl).toBe('https://x.com');
-  });
-
-  it('constructor defaults port to 3001', () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    expect((ch as any).port).toBe(3001);
-  });
-
-  it('constructor uses custom port', () => {
-    const ch = new TelegramChannel({ token: 'tok', port: 8080 });
-    expect((ch as any).port).toBe(8080);
-  });
-
-  it('type is telegram', () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    expect(ch.type).toBe('telegram');
-  });
-
-  it('processUpdate extracts message text', async () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    const messages: any[] = [];
-    (ch as any).handler = async (msg: any) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() }; };
-    // Mock sendMessage to avoid actual API call
-    (ch as any).sendMessage = vi.fn();
-    await (ch as any).processUpdate({
-      message: { message_id: 1, text: 'hello', date: 1000, chat: { id: 123 }, from: { id: 456, first_name: 'Test' } },
-    });
-    expect(messages).toHaveLength(1);
-    expect(messages[0].content).toBe('hello');
-  });
-
-  it('processUpdate handles edited_message', async () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    const messages: any[] = [];
-    (ch as any).handler = async (msg: any) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() }; };
-    (ch as any).sendMessage = vi.fn();
-    await (ch as any).processUpdate({
-      edited_message: { message_id: 2, text: 'edited', date: 1000, chat: { id: 123 }, from: { id: 456, first_name: 'Test' } },
-    });
-    expect(messages).toHaveLength(1);
-    expect(messages[0].content).toBe('edited');
-  });
-
-  it('processUpdate ignores non-text updates', async () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    const messages: any[] = [];
-    ch.onMessage(async (msg) => { messages.push(msg); return { id: 'r', role: 'assistant', content: 'ok', timestamp: Date.now() } as any; });
-    (ch as any).sendMessage = vi.fn();
-    await (ch as any).processUpdate({
-      message: { message_id: 3, photo: [{}], date: 1000, chat: { id: 123 }, from: { id: 456 } },
-    });
-    expect(messages).toHaveLength(0);
-  });
-
-  it('processUpdate ignores update without handler', async () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    // Should not throw
-    await (ch as any).processUpdate({
-      message: { message_id: 4, text: 'hello', date: 1000, chat: { id: 123 }, from: { id: 456 } },
-    });
-  });
-
-  it('offset starts at 0', () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    expect((ch as any).offset).toBe(0);
-  });
-
-  it('missing token results in empty string', () => {
-    const orig = process.env.TELEGRAM_BOT_TOKEN;
-    delete process.env.TELEGRAM_BOT_TOKEN;
-    const ch = new TelegramChannel({});
-    expect((ch as any).token).toBe('');
-    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
-  });
-
-  it('start with no token warns but does not throw', async () => {
-    const orig = process.env.TELEGRAM_BOT_TOKEN;
-    delete process.env.TELEGRAM_BOT_TOKEN;
-    const ch = new TelegramChannel({});
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    await ch.start();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-    if (orig) process.env.TELEGRAM_BOT_TOKEN = orig;
-  });
-
-  it('sendMessage is a function', () => {
-    const ch = new TelegramChannel({ token: 'tok' });
-    expect(typeof (ch as any).sendMessage === 'function' || typeof (ch as any).apiCall === 'function').toBe(true);
-  });
-
-  it('long message chunking helper if available', () => {
-    // Test the concept - messages over 4096 chars should be split
-    const longText = 'a'.repeat(5000);
-    const chunks: string[] = [];
-    for (let i = 0; i < longText.length; i += 4096) {
-      chunks.push(longText.slice(i, i + 4096));
-    }
-    expect(chunks).toHaveLength(2);
-    expect(chunks[0].length).toBe(4096);
-    expect(chunks[1].length).toBe(904);
-  });
-});

package/tests/channels/websocket.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { WebSocketChannel } from '../../src/channels/websocket';
-
-// We can't easily test WebSocket server without starting it, 
-// but we can test the room management and config logic.
-
-describe('WebSocketChannel', () => {
-  describe('constructor', () => {
-    it('should accept port number', () => {
-      const channel = new WebSocketChannel(4000);
-      expect(channel.type).toBe('websocket');
-    });
-
-    it('should accept config object', () => {
-      const channel = new WebSocketChannel({
-        port: 4000,
-        heartbeatInterval: 15000,
-        authTokens: ['secret'],
-        maxClientsPerRoom: 50,
-      });
-      expect(channel.type).toBe('websocket');
-    });
-
-    it('should use defaults', () => {
-      const channel = new WebSocketChannel();
-      expect(channel.type).toBe('websocket');
-    });
-  });
-
-  describe('getStats', () => {
-    it('should return empty stats initially', () => {
-      const channel = new WebSocketChannel(4001);
-      const stats = channel.getStats();
-      expect(stats.clients).toBe(0);
-      expect(stats.rooms).toBe(0);
-      expect(stats.roomDetails).toEqual({});
-    });
-  });
-
-  describe('getRooms', () => {
-    it('should return empty array initially', () => {
-      const channel = new WebSocketChannel(4002);
-      expect(channel.getRooms()).toEqual([]);
-    });
-  });
-
-  describe('getRoomMembers', () => {
-    it('should return empty for non-existent room', () => {
-      const channel = new WebSocketChannel(4003);
-      expect(channel.getRoomMembers('nonexistent')).toEqual([]);
-    });
-  });
-});

package/tests/channels/wechat.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { WeChatChannel } from '../../src/channels/wechat';
-import * as crypto from 'crypto';
-
-describe('WeChatChannel', () => {
-  // ── XML Parsing ──────────────────────────────────
-
-  describe('parseXML', () => {
-    it('should parse text message XML', () => {
-      const xml = `<xml>
-        <ToUserName><![CDATA[gh_123456]]></ToUserName>
-        <FromUserName><![CDATA[oUser123]]></FromUserName>
-        <CreateTime>1348831860</CreateTime>
-        <MsgType><![CDATA[text]]></MsgType>
-        <Content><![CDATA[Hello World]]></Content>
-        <MsgId>1234567890123456</MsgId>
-      </xml>`;
-
-      const msg = WeChatChannel.parseXML(xml);
-      expect(msg).not.toBeNull();
-      expect(msg!.toUserName).toBe('gh_123456');
-      expect(msg!.fromUserName).toBe('oUser123');
-      expect(msg!.createTime).toBe(1348831860);
-      expect(msg!.msgType).toBe('text');
-      expect(msg!.content).toBe('Hello World');
-      expect(msg!.msgId).toBe('1234567890123456');
-    });
-
-    it('should parse event message XML (subscribe)', () => {
-      const xml = `<xml>
-        <ToUserName><![CDATA[gh_123456]]></ToUserName>
-        <FromUserName><![CDATA[oUser123]]></FromUserName>
-        <CreateTime>1348831860</CreateTime>
-        <MsgType><![CDATA[event]]></MsgType>
-        <Event><![CDATA[subscribe]]></Event>
-      </xml>`;
-
-      const msg = WeChatChannel.parseXML(xml);
-      expect(msg).not.toBeNull();
-      expect(msg!.msgType).toBe('event');
-      expect(msg!.event).toBe('subscribe');
-    });
-
-    it('should parse image message XML', () => {
-      const xml = `<xml>
-        <ToUserName><![CDATA[gh_123456]]></ToUserName>
-        <FromUserName><![CDATA[oUser123]]></FromUserName>
-        <CreateTime>1348831860</CreateTime>
-        <MsgType><![CDATA[image]]></MsgType>
-        <MsgId>1234567890123456</MsgId>
-      </xml>`;
-
-      const msg = WeChatChannel.parseXML(xml);
-      expect(msg).not.toBeNull();
-      expect(msg!.msgType).toBe('image');
-    });
-
-    it('should return null for invalid XML', () => {
-      expect(WeChatChannel.parseXML('')).toBeNull();
-      expect(WeChatChannel.parseXML('not xml')).toBeNull();
-      expect(WeChatChannel.parseXML('<xml></xml>')).toBeNull();
-    });
-
-    it('should handle XML with plain text (no CDATA)', () => {
-      const xml = `<xml>
-        <ToUserName>gh_123456</ToUserName>
-        <FromUserName>oUser123</FromUserName>
-        <CreateTime>1348831860</CreateTime>
-        <MsgType>text</MsgType>
-        <Content>Hello</Content>
-      </xml>`;
-
-      const msg = WeChatChannel.parseXML(xml);
-      expect(msg).not.toBeNull();
-      expect(msg!.content).toBe('Hello');
-    });
-  });
-
-  // ── XML Response Formatting ──────────────────────
-
-  describe('formatXMLResponse', () => {
-    it('should format valid XML response', () => {
-      const xml = WeChatChannel.formatXMLResponse('oUser123', 'gh_123456', 'Hello!');
-      expect(xml).toContain('<ToUserName><![CDATA[oUser123]]></ToUserName>');
-      expect(xml).toContain('<FromUserName><![CDATA[gh_123456]]></FromUserName>');
-      expect(xml).toContain('<Content><![CDATA[Hello!]]></Content>');
-      expect(xml).toContain('<MsgType><![CDATA[text]]></MsgType>');
-      expect(xml).toContain('<CreateTime>');
-    });
-
-    it('should handle special characters in content', () => {
-      const xml = WeChatChannel.formatXMLResponse('u', 'g', 'Hello <world> & "friends"');
-      expect(xml).toContain('Hello <world> & "friends"');
-    });
-  });
-
-  // ── Signature Verification ───────────────────────
-
-  describe('verifySignature', () => {
-    it('should verify valid signature', () => {
-      const token = 'mytoken123';
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token });
-
-      const timestamp = '1348831860';
-      const nonce = 'abc123';
-      const arr = [token, timestamp, nonce].sort();
-      const expectedSignature = crypto.createHash('sha1').update(arr.join('')).digest('hex');
-
-      expect(channel.verifySignature(expectedSignature, timestamp, nonce)).toBe(true);
-    });
-
-    it('should reject invalid signature', () => {
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'mytoken' });
-      expect(channel.verifySignature('invalidsig', '123', 'abc')).toBe(false);
-    });
-
-    it('should handle empty inputs', () => {
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
-      expect(channel.verifySignature('', '', '')).toBe(false);
-    });
-  });
-
-  // ── Message Handling ─────────────────────────────
-
-  describe('handleMessage', () => {
-    it('should handle subscribe event', async () => {
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
-      const result = await channel.handleMessage({
-        toUserName: 'gh_123',
-        fromUserName: 'oUser',
-        createTime: 1000,
-        msgType: 'event',
-        event: 'subscribe',
-      });
-      expect(result).toContain('Welcome');
-    });
-
-    it('should handle text message with handler', async () => {
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
-      channel.onMessage(async (msg) => ({
-        id: 'reply',
-        role: 'assistant',
-        content: `Echo: ${msg.content}`,
-        timestamp: Date.now(),
-      }));
-
-      const result = await channel.handleMessage({
-        toUserName: 'gh_123',
-        fromUserName: 'oUser',
-        createTime: 1000,
-        msgType: 'text',
-        content: 'Hello',
-        msgId: 'msg1',
-      });
-      expect(result).toBe('Echo: Hello');
-    });
-
-    it('should return empty for text message without handler', async () => {
-      const channel = new WeChatChannel({ appId: 'id', appSecret: 'secret', token: 'tok' });
-      const result = await channel.handleMessage({
-        toUserName: 'gh_123',
-        fromUserName: 'oUser',
-        createTime: 1000,
-        msgType: 'text',
-        content: 'Hello',
-      });
-      expect(result).toBe('');
-    });
-  });
-});

package/tests/channels-extra.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { WhatsAppChannel } from '../src/channels/whatsapp';
-import { SignalChannel } from '../src/channels/signal';
-import { MatrixChannel } from '../src/channels/matrix';
-import { IMessageChannel } from '../src/channels/imessage';
-import { LINEChannel } from '../src/channels/line';
-import { MSTeamsChannel } from '../src/channels/msteams';
-import { QQChannel } from '../src/channels/qq';
-import { NostrChannel } from '../src/channels/nostr';
-import { SMSChannel } from '../src/channels/sms';
-
-describe('Additional Channels', () => {
-  it('should create WhatsApp channel', () => {
-    const ch = new WhatsAppChannel({ phoneNumber: '+1234567890' });
-    expect(ch.type).toBe('whatsapp');
-  });
-
-  it('should throw on start without deps', async () => {
-    const ch = new SignalChannel();
-    await expect(ch.start()).rejects.toThrow(/Install/);
-  });
-
-  it('should create Matrix channel', () => {
-    const ch = new MatrixChannel({ homeserverUrl: 'https://matrix.org' });
-    expect(ch.type).toBe('matrix');
-  });
-
-  it('should create all channel types', () => {
-    const channels = [
-      new IMessageChannel(),
-      new LINEChannel(),
-      new MSTeamsChannel(),
-      new QQChannel(),
-      new NostrChannel(),
-      new SMSChannel(),
-    ];
-    const types = channels.map(c => c.type);
-    expect(types).toEqual(['imessage', 'line', 'msteams', 'qq', 'nostr', 'sms']);
-  });
-
-  it('should throw on send before start', async () => {
-    const ch = new WhatsAppChannel();
-    await expect(ch.send('123', 'hello')).rejects.toThrow(/not yet connected/);
-  });
-});