@auxiora/channels 1.0.0

package/tests/teams.test.ts

@@ -0,0 +1,429 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { TeamsAdapter } from '../src/adapters/teams.js';
+
+// Mock audit
+vi.mock('@auxiora/audit', () => ({
+  audit: vi.fn(),
+}));
+
+describe('TeamsAdapter', () => {
+  let adapter: TeamsAdapter;
+
+  beforeEach(() => {
+    adapter = new TeamsAdapter({
+      microsoftAppId: 'test-app-id',
+      microsoftAppPassword: 'test-app-password',
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should have correct metadata', () => {
+    expect(adapter.type).toBe('teams');
+    expect(adapter.name).toBe('Microsoft Teams');
+    expect(adapter.isConnected()).toBe(false);
+  });
+
+  it('should connect successfully', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+
+    await adapter.connect();
+    expect(adapter.isConnected()).toBe(true);
+
+    await adapter.disconnect();
+    expect(adapter.isConnected()).toBe(false);
+  });
+
+  it('should fail to connect with invalid credentials', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      statusText: 'Unauthorized',
+    } as Response);
+
+    await expect(adapter.connect()).rejects.toThrow('Failed to obtain Teams token');
+  });
+
+  it('should handle incoming webhook activity', async () => {
+    // Connect first
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    const receivedMessages: unknown[] = [];
+    adapter.onMessage(async (msg) => {
+      receivedMessages.push(msg);
+    });
+
+    const activity = {
+      type: 'message',
+      id: 'activity-123',
+      timestamp: '2024-01-01T00:00:00Z',
+      channelId: 'msteams',
+      from: {
+        id: 'user-1',
+        name: 'Alice',
+      },
+      conversation: {
+        id: 'conv-1',
+        isGroup: false,
+      },
+      text: 'Hello Teams!',
+      serviceUrl: 'https://smba.trafficmanager.net/teams/',
+    };
+
+    await adapter.handleWebhook(activity);
+
+    expect(receivedMessages).toHaveLength(1);
+    const msg = receivedMessages[0] as { content: string; senderId: string; senderName: string };
+    expect(msg.content).toBe('Hello Teams!');
+    expect(msg.senderId).toBe('user-1');
+    expect(msg.senderName).toBe('Alice');
+
+    await adapter.disconnect();
+  });
+
+  it('should ignore non-message activities', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    const receivedMessages: unknown[] = [];
+    adapter.onMessage(async (msg) => {
+      receivedMessages.push(msg);
+    });
+
+    await adapter.handleWebhook({
+      type: 'conversationUpdate',
+      id: 'activity-456',
+      timestamp: '2024-01-01T00:00:00Z',
+      channelId: 'msteams',
+      from: { id: 'user-1' },
+      conversation: { id: 'conv-1' },
+      serviceUrl: 'https://smba.trafficmanager.net/teams/',
+    });
+
+    expect(receivedMessages).toHaveLength(0);
+
+    await adapter.disconnect();
+  });
+
+  it('should send a message successfully', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ id: 'msg-1' }),
+    } as Response);
+
+    const result = await adapter.send('conv-1', {
+      content: 'Hello from the bot!',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.messageId).toBe('msg-1');
+
+    await adapter.disconnect();
+  });
+
+  it('should handle send errors', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      statusText: 'Forbidden',
+      text: async () => 'Bot not authorized',
+    } as unknown as Response);
+
+    const result = await adapter.send('conv-1', {
+      content: 'Should fail',
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('403');
+
+    await adapter.disconnect();
+  });
+
+  it('should strip bot mention from message text', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    const receivedMessages: unknown[] = [];
+    adapter.onMessage(async (msg) => {
+      receivedMessages.push(msg);
+    });
+
+    await adapter.handleWebhook({
+      type: 'message',
+      id: 'activity-789',
+      timestamp: '2024-01-01T00:00:00Z',
+      channelId: 'msteams',
+      from: { id: 'user-1', name: 'Alice' },
+      conversation: { id: 'conv-1' },
+      recipient: { id: 'bot-1', name: 'Auxiora' },
+      text: '<at>Auxiora</at> what is the weather?',
+      serviceUrl: 'https://smba.trafficmanager.net/teams/',
+    });
+
+    expect(receivedMessages).toHaveLength(1);
+    const msg = receivedMessages[0] as { content: string };
+    expect(msg.content).toBe('what is the weather?');
+
+    await adapter.disconnect();
+  });
+
+  it('should cache access token', async () => {
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        access_token: 'test-token',
+        expires_in: 3600,
+        token_type: 'Bearer',
+      }),
+    } as Response);
+    await adapter.connect();
+
+    // Send two messages - should only call token endpoint once
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ id: 'msg-1' }),
+    } as Response);
+    await adapter.send('conv-1', { content: 'Message 1' });
+
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ id: 'msg-2' }),
+    } as Response);
+    await adapter.send('conv-1', { content: 'Message 2' });
+
+    // Only 1 token call (during connect) + 2 send calls = 3 total
+    expect(fetchSpy).toHaveBeenCalledTimes(3);
+
+    await adapter.disconnect();
+  });
+
+  it('should register error handler', () => {
+    const handler = vi.fn();
+    adapter.onError(handler);
+  });
+
+  describe('sender filtering', () => {
+    it('should allow all messages when allowlists are not set', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ access_token: 'test-token', expires_in: 3600, token_type: 'Bearer' }),
+      } as Response);
+      await adapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      adapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await adapter.handleWebhook({
+        type: 'message',
+        id: 'activity-filter-1',
+        timestamp: '2024-01-01T00:00:00Z',
+        channelId: 'msteams',
+        from: { id: 'any-user', name: 'Anyone' },
+        conversation: { id: 'conv-1', tenantId: 'any-tenant' },
+        text: 'Hello!',
+        serviceUrl: 'https://smba.trafficmanager.net/teams/',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await adapter.disconnect();
+    });
+
+    it('should allow messages from allowed tenants and users', async () => {
+      const filteredAdapter = new TeamsAdapter({
+        microsoftAppId: 'test-app-id',
+        microsoftAppPassword: 'test-app-password',
+        allowedTenants: ['tenant-1'],
+        allowedUsers: ['user-1'],
+      });
+
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ access_token: 'test-token', expires_in: 3600, token_type: 'Bearer' }),
+      } as Response);
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        type: 'message',
+        id: 'activity-filter-2',
+        timestamp: '2024-01-01T00:00:00Z',
+        channelId: 'msteams',
+        from: { id: 'user-1', name: 'Alice' },
+        conversation: { id: 'conv-1', tenantId: 'tenant-1' },
+        text: 'Allowed!',
+        serviceUrl: 'https://smba.trafficmanager.net/teams/',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await filteredAdapter.disconnect();
+    });
+
+    it('should block messages from non-allowed tenants', async () => {
+      const { audit } = await import('@auxiora/audit');
+      const filteredAdapter = new TeamsAdapter({
+        microsoftAppId: 'test-app-id',
+        microsoftAppPassword: 'test-app-password',
+        allowedTenants: ['tenant-1'],
+      });
+
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ access_token: 'test-token', expires_in: 3600, token_type: 'Bearer' }),
+      } as Response);
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        type: 'message',
+        id: 'activity-filter-3',
+        timestamp: '2024-01-01T00:00:00Z',
+        channelId: 'msteams',
+        from: { id: 'user-1', name: 'Alice' },
+        conversation: { id: 'conv-1', tenantId: 'wrong-tenant' },
+        text: 'Blocked!',
+        serviceUrl: 'https://smba.trafficmanager.net/teams/',
+      });
+
+      expect(receivedMessages).toHaveLength(0);
+      expect(audit).toHaveBeenCalledWith('message.filtered', expect.objectContaining({
+        channelType: 'teams',
+        tenantId: 'wrong-tenant',
+        reason: 'tenant_not_allowed',
+      }));
+      await filteredAdapter.disconnect();
+    });
+
+    it('should block messages from non-allowed users', async () => {
+      const { audit } = await import('@auxiora/audit');
+      const filteredAdapter = new TeamsAdapter({
+        microsoftAppId: 'test-app-id',
+        microsoftAppPassword: 'test-app-password',
+        allowedUsers: ['user-1'],
+      });
+
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ access_token: 'test-token', expires_in: 3600, token_type: 'Bearer' }),
+      } as Response);
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        type: 'message',
+        id: 'activity-filter-4',
+        timestamp: '2024-01-01T00:00:00Z',
+        channelId: 'msteams',
+        from: { id: 'user-2', name: 'Eve' },
+        conversation: { id: 'conv-1' },
+        text: 'Blocked!',
+        serviceUrl: 'https://smba.trafficmanager.net/teams/',
+      });
+
+      expect(receivedMessages).toHaveLength(0);
+      expect(audit).toHaveBeenCalledWith('message.filtered', expect.objectContaining({
+        channelType: 'teams',
+        senderId: 'user-2',
+        reason: 'user_not_allowed',
+      }));
+      await filteredAdapter.disconnect();
+    });
+
+    it('should allow messages when tenantId is undefined even with allowedTenants set', async () => {
+      const filteredAdapter = new TeamsAdapter({
+        microsoftAppId: 'test-app-id',
+        microsoftAppPassword: 'test-app-password',
+        allowedTenants: ['tenant-1'],
+      });
+
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ access_token: 'test-token', expires_in: 3600, token_type: 'Bearer' }),
+      } as Response);
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        type: 'message',
+        id: 'activity-filter-5',
+        timestamp: '2024-01-01T00:00:00Z',
+        channelId: 'msteams',
+        from: { id: 'user-1', name: 'Alice' },
+        conversation: { id: 'conv-1' }, // no tenantId
+        text: 'No tenant!',
+        serviceUrl: 'https://smba.trafficmanager.net/teams/',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await filteredAdapter.disconnect();
+    });
+  });
+});

package/tests/twilio.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { TwilioAdapter } from '../src/adapters/twilio.js';
+import type { TwilioWebhookBody } from '../src/adapters/twilio.js';
+
+// Mock audit
+vi.mock('@auxiora/audit', () => ({
+  audit: vi.fn(),
+}));
+
+// Mock twilio
+vi.mock('twilio', () => {
+  const mockCreate = vi.fn().mockResolvedValue({ sid: 'SM123' });
+  const mockFetch = vi.fn().mockResolvedValue({ sid: 'AC123' });
+  const mockTwilio = vi.fn(() => ({
+    api: { accounts: vi.fn(() => ({ fetch: mockFetch })) },
+    messages: { create: mockCreate },
+  }));
+  // Add validateRequest as a static method
+  mockTwilio.validateRequest = vi.fn(() => true);
+  return { default: mockTwilio };
+});
+
+describe('TwilioAdapter', () => {
+  let adapter: TwilioAdapter;
+
+  beforeEach(() => {
+    adapter = new TwilioAdapter({
+      accountSid: 'AC123',
+      authToken: 'test-auth-token',
+      phoneNumber: '+1234567890',
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should have correct metadata', () => {
+    expect(adapter.type).toBe('twilio');
+    expect(adapter.name).toBe('Twilio');
+    expect(adapter.isConnected()).toBe(false);
+  });
+
+  it('should connect successfully', async () => {
+    await adapter.connect();
+    expect(adapter.isConnected()).toBe(true);
+
+    await adapter.disconnect();
+    expect(adapter.isConnected()).toBe(false);
+  });
+
+  it('should handle incoming SMS webhook', async () => {
+    await adapter.connect();
+
+    const receivedMessages: unknown[] = [];
+    adapter.onMessage(async (msg) => {
+      receivedMessages.push(msg);
+    });
+
+    const body: TwilioWebhookBody = {
+      MessageSid: 'SM456',
+      AccountSid: 'AC123',
+      From: '+0987654321',
+      To: '+1234567890',
+      Body: 'Hello via SMS!',
+    };
+
+    const result = await adapter.handleWebhook(body);
+
+    expect(result).toBeNull();
+    expect(receivedMessages).toHaveLength(1);
+    const msg = receivedMessages[0] as { content: string; senderId: string; channelId: string };
+    expect(msg.content).toBe('Hello via SMS!');
+    expect(msg.senderId).toBe('+0987654321');
+    expect(msg.channelId).toBe('sms');
+
+    await adapter.disconnect();
+  });
+
+  it('should handle incoming WhatsApp webhook', async () => {
+    await adapter.connect();
+
+    const receivedMessages: unknown[] = [];
+    adapter.onMessage(async (msg) => {
+      receivedMessages.push(msg);
+    });
+
+    const body: TwilioWebhookBody = {
+      MessageSid: 'SM789',
+      AccountSid: 'AC123',
+      From: 'whatsapp:+0987654321',
+      To: 'whatsapp:+1234567890',
+      Body: 'Hello via WhatsApp!',
+    };
+
+    await adapter.handleWebhook(body);
+
+    expect(receivedMessages).toHaveLength(1);
+    const msg = receivedMessages[0] as { channelId: string };
+    expect(msg.channelId).toBe('whatsapp');
+
+    await adapter.disconnect();
+  });
+
+  describe('sender filtering', () => {
+    it('should allow all messages when allowedNumbers is not set', async () => {
+      await adapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      adapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await adapter.handleWebhook({
+        MessageSid: 'SM001',
+        AccountSid: 'AC123',
+        From: '+5555555555',
+        To: '+1234567890',
+        Body: 'Anyone!',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await adapter.disconnect();
+    });
+
+    it('should allow messages from allowed numbers', async () => {
+      const filteredAdapter = new TwilioAdapter({
+        accountSid: 'AC123',
+        authToken: 'test-auth-token',
+        phoneNumber: '+1234567890',
+        allowedNumbers: ['+0987654321'],
+      });
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        MessageSid: 'SM002',
+        AccountSid: 'AC123',
+        From: '+0987654321',
+        To: '+1234567890',
+        Body: 'Allowed!',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await filteredAdapter.disconnect();
+    });
+
+    it('should block messages from non-allowed numbers', async () => {
+      const { audit } = await import('@auxiora/audit');
+      const filteredAdapter = new TwilioAdapter({
+        accountSid: 'AC123',
+        authToken: 'test-auth-token',
+        phoneNumber: '+1234567890',
+        allowedNumbers: ['+0987654321'],
+      });
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      const result = await filteredAdapter.handleWebhook({
+        MessageSid: 'SM003',
+        AccountSid: 'AC123',
+        From: '+5555555555',
+        To: '+1234567890',
+        Body: 'Blocked!',
+      });
+
+      expect(result).toBeNull();
+      expect(receivedMessages).toHaveLength(0);
+      expect(audit).toHaveBeenCalledWith('message.filtered', expect.objectContaining({
+        channelType: 'twilio',
+        senderId: '+5555555555',
+        reason: 'number_not_allowed',
+      }));
+      await filteredAdapter.disconnect();
+    });
+
+    it('should strip whatsapp: prefix before matching allowedNumbers', async () => {
+      const filteredAdapter = new TwilioAdapter({
+        accountSid: 'AC123',
+        authToken: 'test-auth-token',
+        phoneNumber: '+1234567890',
+        allowedNumbers: ['+0987654321'],
+      });
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      // WhatsApp message with whatsapp: prefix, but number is in allowedNumbers
+      await filteredAdapter.handleWebhook({
+        MessageSid: 'SM004',
+        AccountSid: 'AC123',
+        From: 'whatsapp:+0987654321',
+        To: 'whatsapp:+1234567890',
+        Body: 'WhatsApp allowed!',
+      });
+
+      expect(receivedMessages).toHaveLength(1);
+      await filteredAdapter.disconnect();
+    });
+
+    it('should block WhatsApp messages from non-allowed numbers', async () => {
+      const { audit } = await import('@auxiora/audit');
+      const filteredAdapter = new TwilioAdapter({
+        accountSid: 'AC123',
+        authToken: 'test-auth-token',
+        phoneNumber: '+1234567890',
+        allowedNumbers: ['+0987654321'],
+      });
+      await filteredAdapter.connect();
+
+      const receivedMessages: unknown[] = [];
+      filteredAdapter.onMessage(async (msg) => {
+        receivedMessages.push(msg);
+      });
+
+      await filteredAdapter.handleWebhook({
+        MessageSid: 'SM005',
+        AccountSid: 'AC123',
+        From: 'whatsapp:+5555555555',
+        To: 'whatsapp:+1234567890',
+        Body: 'Blocked WhatsApp!',
+      });
+
+      expect(receivedMessages).toHaveLength(0);
+      expect(audit).toHaveBeenCalledWith('message.filtered', expect.objectContaining({
+        channelType: 'twilio',
+        reason: 'number_not_allowed',
+      }));
+      await filteredAdapter.disconnect();
+    });
+  });
+
+  it('should handle message handler errors gracefully', async () => {
+    await adapter.connect();
+
+    const errorHandler = vi.fn();
+    adapter.onError(errorHandler);
+    adapter.onMessage(async () => {
+      throw new Error('Handler error');
+    });
+
+    await adapter.handleWebhook({
+      MessageSid: 'SM999',
+      AccountSid: 'AC123',
+      From: '+0987654321',
+      To: '+1234567890',
+      Body: 'Trigger error',
+    });
+
+    expect(errorHandler).toHaveBeenCalledWith(expect.any(Error));
+    await adapter.disconnect();
+  });
+
+  it('should register error handler', () => {
+    const handler = vi.fn();
+    adapter.onError(handler);
+  });
+});