Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
32.9 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
// ── Import under test ─────────────────────────────────────────────────────────

import { SlackAdapter } from '../../src/channels/slack.js'
import {
  isSlackVerifyCommand,
  parseSlackVerifyCommand,
  redactSlackVerificationText,
} from '../../src/channels/slackVerification.js'

// ── Hoisted shared state ──────────────────────────────────────────────────────

const slackState = vi.hoisted(() => ({
  instances: [] as Array<{
    auth: { test: ReturnType<typeof vi.fn> }
    conversations: {
      history: ReturnType<typeof vi.fn>
      info: ReturnType<typeof vi.fn>
      list: ReturnType<typeof vi.fn>
    }
    users: { info: ReturnType<typeof vi.fn> }
    chat: { postMessage: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn> }
    files: { uploadV2: ReturnType<typeof vi.fn> }
  }>,
}))

const TEST_TOKEN = 'xoxb-test-000000'

// ── Mocks ─────────────────────────────────────────────────────────────────────

vi.mock('../../src/config.js', () => ({
  config: {
    mcpHostUrl: 'http://mcp-host.test',
    enableResponseAttachments: true,
    attachmentMaxBytes: 1024 * 1024,
    attachmentMaxCount: 4,
  },
}))

vi.mock('@slack/web-api', () => ({
  // Must use `function` for constructor mocking with `new`
  WebClient: vi.fn().mockImplementation(function () {
    const instance = {
      auth: {
        test: vi.fn().mockResolvedValue({
          user: 'clerum_bot',
          user_id: 'U_BOT888',
          team_id: 'T123',
          ok: true,
        }),
      },
      conversations: {
        history: vi.fn().mockResolvedValue({ messages: [], ok: true }),
        info: vi.fn().mockResolvedValue({
          channel: { id: 'C12345', name: 'general', is_channel: true },
          ok: true,
        }),
        list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
      },
      users: {
        info: vi.fn().mockResolvedValue({
          user: { name: 'testuser', ok: true },
          ok: true,
        }),
      },
      chat: {
        postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        update: vi.fn().mockResolvedValue({ ok: true }),
      },
      files: {
        uploadV2: vi.fn().mockResolvedValue({ ok: true }),
      },
    }
    slackState.instances.push(instance)
    return instance
  }),
}))

// ── Setup ─────────────────────────────────────────────────────────────────────

beforeEach(() => {
  slackState.instances.length = 0
})

// ── connect() ─────────────────────────────────────────────────────────────────

describe('SlackAdapter — connect()', () => {
  it('creates a WebClient with the configured token', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    expect(slackState.instances).toHaveLength(1)
  })

  it('calls auth.test() to verify connection', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    expect(slackState.instances[0]!.auth.test).toHaveBeenCalledOnce()
  })

  it('skips connection when slackBotToken is not configured', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: undefined })

    expect(slackState.instances).toHaveLength(0)
  })

  it('handles auth.test() failure gracefully (nullifies client)', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockRejectedValue(new Error('invalid_auth')),
        },
        conversations: { history: vi.fn(), list: vi.fn() },
        users: { info: vi.fn() },
        chat: { postMessage: vi.fn() },
      }
      slackState.instances.push(instance as never)
      return instance as never
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    // connect() should not throw
    // After a failed auth.test(), client is nullified → fetchMessages returns []
    const messages = await adapter.fetchMessages('general', new Set(['user1']))
    expect(messages).toEqual([])
  })
})

describe('Slack verification command parsing', () => {
  it('accepts plain Slack verify messages without slash-command interception', () => {
    expect(isSlackVerifyCommand('verify 123456')).toBe(true)
    expect(parseSlackVerifyCommand('verify 123456')).toBe('123456')
  })

  it('accepts Slack app mentions before the verify command', () => {
    expect(isSlackVerifyCommand('<@UBOT888> verify 123456')).toBe(true)
    expect(parseSlackVerifyCommand('<@UBOT888> verify 123456')).toBe('123456')
  })

  it('redacts Slack verification messages that mention the app', () => {
    expect(redactSlackVerificationText('<@UBOT888> verify 123456')).toBe('verify [redacted]')
  })
})

describe('SlackAdapter — conversation metadata', () => {
  it('reads the Slack conversation title and type for confirmed conversations', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!

    client.conversations.info.mockResolvedValueOnce({
      channel: { id: 'G12345', name: 'leadership', is_private: true },
      ok: true,
    })

    await expect(adapter.getConversationMetadata('G12345', 'U123')).resolves.toEqual({
      providerChannelType: 'private_channel',
      providerChannelTitle: '#leadership',
    })
    expect(client.conversations.info).toHaveBeenCalledWith({ channel: 'G12345' })
  })

  it('uses the Slack user display name for direct-message metadata', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!

    client.conversations.info.mockResolvedValueOnce({
      channel: { id: 'D12345', is_im: true, user: 'U123' },
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'josue' },
      ok: true,
    })

    await expect(adapter.getConversationMetadata('D12345', null)).resolves.toEqual({
      providerChannelType: 'im',
      providerChannelTitle: '@josue',
    })
  })
})

// ── disconnect() ──────────────────────────────────────────────────────────────

describe('SlackAdapter — disconnect()', () => {
  it('is safe to call disconnect() before connect()', async () => {
    const adapter = new SlackAdapter()
    await expect(adapter.disconnect()).resolves.toBeUndefined()
  })

  it('nullifies client on disconnect', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    await adapter.disconnect()

    // After disconnect, fetchMessages returns [] (no client)
    const messages = await adapter.fetchMessages('general', new Set(['anyone']))
    expect(messages).toEqual([])
  })
})

// ── fetchMessages() ───────────────────────────────────────────────────────────

describe('SlackAdapter — fetchMessages()', () => {
  it('returns empty array when not connected', async () => {
    const adapter = new SlackAdapter()
    // No connect()

    const messages = await adapter.fetchMessages('C12345', new Set(['user1']))
    expect(messages).toEqual([])
  })

  it('returns empty array when no messages in history', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({ messages: [], ok: true })

    const messages = await adapter.fetchMessages('C12345', new Set(['user1']))
    expect(messages).toEqual([])
  })

  it('filters messages from allowed users by stable user ID and records workspace identity', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U123', text: 'Hello', ts: '1700000001.000001' }],
      ok: true,
    })
    // User lookup returns username "alice"
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['U123']))
    expect(messages).toHaveLength(1)
    expect(messages[0]!.sender).toBe('U123')
    expect(messages[0]!.content).toBe('Hello')
    expect(messages[0]!.channelType).toBe('slack')
    expect(messages[0]!.providerIdentity).toEqual({
      medium: 'slack',
      providerUserId: 'U123',
      providerWorkspaceId: 'T123',
      providerChannelId: 'C12345',
      providerEventId: 'slack:T123:C12345:1700000001.000001',
    })
  })

  it('rejects messages when configured workspace does not match the verified Slack workspace', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [
        {
          user: 'U123',
          text: '/approve due-diligence-review',
          ts: '1700000001.000005',
        },
      ],
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['U123']), {
      providerWorkspaceId: 'T999',
    })
    expect(messages).toHaveLength(0)
  })

  it('uses Slack event workspace identity when auth.test does not expose team_id', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', user_id: 'U_BOT888', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [
              {
                user: 'U123',
                team: 'T123',
                text: '/approve due-diligence-review',
                ts: '1700000001.000006',
              },
            ],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const messages = await adapter.fetchMessages('C12345', new Set(['U123']), {
      providerWorkspaceId: 'T123',
    })
    expect(messages).toHaveLength(1)
    expect(messages[0]!.providerIdentity).toEqual({
      medium: 'slack',
      providerUserId: 'U123',
      providerWorkspaceId: 'T123',
      providerChannelId: 'C12345',
      providerEventId: 'slack:T123:C12345:1700000001.000006',
    })
  })

  it('does not emit slack:unknown provider identities when workspace identity is unavailable', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', user_id: 'U_BOT888', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [
              {
                user: 'U123',
                text: 'legacy hello',
                ts: '1700000001.000007',
              },
            ],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(1)
    expect(messages[0]!.providerIdentity).toBeUndefined()
  })

  it('keeps username allowlists only as legacy chat compatibility', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U123', text: 'legacy hello', ts: '1700000001.000002' }],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(1)
    expect(messages[0]!.sender).toBe('U123')
    expect(messages[0]!.providerIdentity?.providerUserId).toBe('U123')
  })

  it('does not allow workflow approval decisions through legacy username allowlists', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [
        {
          user: 'U123',
          text: '/approve due-diligence-review',
          ts: '1700000001.000003',
        },
      ],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(0)
  })

  it('allows workflow approval decisions only when the stable Slack user ID is allowlisted', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [
        {
          user: 'U123',
          text: '/approve due-diligence-review',
          ts: '1700000001.000004',
        },
      ],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['U123']))
    expect(messages).toHaveLength(1)
    expect(messages[0]!.providerIdentity).toEqual({
      medium: 'slack',
      providerUserId: 'U123',
      providerWorkspaceId: 'T123',
      providerChannelId: 'C12345',
      providerEventId: 'slack:T123:C12345:1700000001.000004',
    })
  })

  it('ignores messages from unauthorized users', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U999', text: 'Spam', ts: '1700000002.000001' }],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'spammer' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(0)
  })

  it('skips bot messages (messages with subtype)', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [
        { user: 'U123', text: 'Bot notification', ts: '1700000003.000001', subtype: 'bot_message' },
      ],
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(0)
  })

  it('skips messages without a user field', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ text: 'System message', ts: '1700000004.000001' }],
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']))
    expect(messages).toHaveLength(0)
  })

  it('with replyOnlyWhenMentioned, drops messages without app mention', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U123', text: 'Hello without mention', ts: '1700000005.000001' }],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(0)
  })

  it('with replyOnlyWhenMentioned, keeps messages that mention the bot', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U123', text: '<@U_BOT888> please help', ts: '1700000006.000001' }],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(1)
    expect(messages[0]!.content).toBe('<@U_BOT888> please help')
  })

  it('with replyOnlyWhenMentioned, /approve bypasses mention requirement', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })

    const client = slackState.instances[0]!
    client.conversations.history.mockResolvedValueOnce({
      messages: [{ user: 'U123', text: '/approve', ts: '1700000007.000001' }],
      ok: true,
    })
    client.users.info.mockResolvedValueOnce({
      user: { name: 'alice' },
      ok: true,
    })

    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(1)
  })

  it('with replyOnlyWhenMentioned, drops messages when bot user_id is missing from auth', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [{ user: 'U123', text: '<@U_BOT888> fake', ts: '1700000008.000001' }],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(0)
  })

  it('with replyOnlyWhenMentioned and missing bot user_id, /approve still passes', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [{ user: 'U123', text: '/approve', ts: '1700000009.000001' }],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(1)
  })

  it('with replyOnlyWhenMentioned, warns once when bot user_id is missing from auth.test', async () => {
    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({ messages: [], ok: true }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    await adapter.fetchMessages('C12345', new Set(['alice']), { replyOnlyWhenMentioned: true })
    await adapter.fetchMessages('C12345', new Set(['alice']), { replyOnlyWhenMentioned: true })

    const missingIdWarns = warnSpy.mock.calls.filter(c =>
      String(c[0]).includes('bot user_id is missing from auth.test')
    )
    expect(missingIdWarns.length).toBe(1)
    warnSpy.mockRestore()
  })

  it('with replyOnlyWhenMentioned and missing bot user_id, /deny still passes', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [{ user: 'U123', text: '/deny', ts: '1700000010.000001' }],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(1)
    expect(messages[0]!.content).toBe('/deny')
  })

  it('with replyOnlyWhenMentioned and missing bot user_id, /approve always still passes', async () => {
    const { WebClient } = await import('@slack/web-api')
    vi.mocked(WebClient).mockImplementationOnce(function () {
      const instance = {
        auth: {
          test: vi.fn().mockResolvedValue({ user: 'clerum_bot', ok: true }),
        },
        conversations: {
          history: vi.fn().mockResolvedValue({
            messages: [{ user: 'U123', text: '/approve always', ts: '1700000011.000001' }],
            ok: true,
          }),
          info: vi.fn().mockResolvedValue({
            channel: { id: 'C12345', name: 'general', is_channel: true },
            ok: true,
          }),
          list: vi.fn().mockResolvedValue({ channels: [], ok: true }),
        },
        users: {
          info: vi.fn().mockResolvedValue({
            user: { name: 'alice' },
            ok: true,
          }),
        },
        chat: {
          postMessage: vi.fn().mockResolvedValue({ ts: '1234567890.000001', ok: true }),
        },
        files: {
          uploadV2: vi.fn().mockResolvedValue({ ok: true }),
        },
      }
      slackState.instances.push(instance)
      return instance
    })

    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const messages = await adapter.fetchMessages('C12345', new Set(['alice']), {
      replyOnlyWhenMentioned: true,
    })
    expect(messages).toHaveLength(1)
    expect(messages[0]!.content).toBe('/approve always')
  })
})

describe('SlackAdapter — sendMessage()', () => {
  it('passes Slack Block Kit options to chat.postMessage', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!
    const slackBlocks = [
      { type: 'section' as const, text: { type: 'mrkdwn' as const, text: 'Approval needed' } },
      {
        type: 'actions' as const,
        elements: [
          {
            type: 'button' as const,
            action_id: 'workflow_approval_approve',
            text: { type: 'plain_text' as const, text: 'Approve' },
            value: 'approve:99999999-8888-7777-6666-555555555555:sandbox-recipes/research',
            style: 'primary' as const,
          },
        ],
      },
    ]

    await adapter.sendMessage('C12345', 'Approval needed', undefined, undefined, { slackBlocks })

    expect(client.chat.postMessage).toHaveBeenCalledWith(
      expect.objectContaining({
        channel: 'C12345',
        text: 'Approval needed',
        blocks: slackBlocks,
      })
    )
  })

  it('updates tool approval blocks and clears them from progress messages', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!
    const blocks = [
      { type: 'section' as const, text: { type: 'mrkdwn' as const, text: 'Approval needed' } },
      {
        type: 'actions' as const,
        elements: [
          {
            type: 'button' as const,
            action_id: 'tool_approval_approve',
            text: { type: 'plain_text' as const, text: 'Approve' },
            value: 'tool:a:abcdefghijklmnop',
          },
        ],
      },
    ]

    await adapter.editMessage('C12345', '1234567890.000001', 'Approval needed', {
      slackBlocks: blocks,
    })
    await adapter.editMessage('C12345', '1234567890.000001', 'Approved. Processing...')

    expect(client.chat.update).toHaveBeenNthCalledWith(1, {
      channel: 'C12345',
      ts: '1234567890.000001',
      text: 'Approval needed',
      blocks,
    })
    expect(client.chat.update).toHaveBeenNthCalledWith(2, {
      channel: 'C12345',
      ts: '1234567890.000001',
      text: 'Approved. Processing...',
      blocks: [],
    })
  })

  it('uploads workflow result documents to Slack files', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!
    const dataBase64 = Buffer.from('{"ok":true}', 'utf8').toString('base64')

    const messageId = await adapter.sendMessage('C12345', 'Workflow result is ready', '170.0001', [
      {
        id: 'artifact-1',
        kind: 'file',
        mimeType: 'application/json',
        encoding: 'base64',
        dataBase64,
        filename: 'result.json',
        sourceTool: 'workflow_result',
      },
    ])

    expect(messageId).toBe('1234567890.000001')
    expect(client.chat.postMessage).toHaveBeenCalledWith(
      expect.objectContaining({
        channel: 'C12345',
        text: 'Workflow result is ready',
        thread_ts: '170.0001',
      })
    )
    expect(client.files.uploadV2).toHaveBeenCalledWith(
      expect.objectContaining({
        channel_id: 'C12345',
        thread_ts: '170.0001',
        file_uploads: [
          expect.objectContaining({
            filename: 'result.json',
            title: 'result.json',
            file: Buffer.from('{"ok":true}', 'utf8'),
          }),
        ],
      })
    )
  })

  it('reports unsupported attachments while still uploading trusted documents', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!

    await adapter.sendMessage('C12345', '', '170.0001', [
      {
        id: 'result-1',
        kind: 'file',
        mimeType: 'application/json',
        encoding: 'base64',
        dataBase64: Buffer.from('{"ok":true}', 'utf8').toString('base64'),
        filename: 'result.json',
        sourceTool: 'workflow_result',
      },
      {
        id: 'generic-1',
        kind: 'file',
        mimeType: 'text/plain',
        encoding: 'base64',
        dataBase64: Buffer.from('hello', 'utf8').toString('base64'),
        filename: 'generic.txt',
      },
    ])

    expect(client.chat.postMessage).toHaveBeenCalledWith(
      expect.objectContaining({
        channel: 'C12345',
        text: '1 attachment was generated but could not be delivered to Slack.',
        thread_ts: '170.0001',
      })
    )
    expect(client.files.uploadV2).toHaveBeenCalledWith(
      expect.objectContaining({
        channel_id: 'C12345',
        thread_ts: '170.0001',
        file_uploads: [
          expect.objectContaining({
            filename: 'result.json',
            title: 'result.json',
            file: Buffer.from('{"ok":true}', 'utf8'),
          }),
        ],
      })
    )
  })

  it('does not upload untrusted generic file attachments', async () => {
    const adapter = new SlackAdapter()
    await adapter.connect({ slackBotToken: TEST_TOKEN })
    const client = slackState.instances[0]!

    await adapter.sendMessage('C12345', 'Plain reply', undefined, [
      {
        id: 'generic-1',
        kind: 'file',
        mimeType: 'text/plain',
        encoding: 'base64',
        dataBase64: Buffer.from('hello', 'utf8').toString('base64'),
        filename: 'generic.txt',
      },
    ])

    expect(client.chat.postMessage).toHaveBeenCalledWith(
      expect.objectContaining({
        channel: 'C12345',
        text: 'Plain reply\n\n[Note: 1 attachment was generated but could not be delivered to Slack.]',
      })
    )
    expect(client.files.uploadV2).not.toHaveBeenCalled()
  })
})

// ── channelType ───────────────────────────────────────────────────────────────

describe('SlackAdapter — channelType', () => {
  it('reports channelType as slack', () => {
    const adapter = new SlackAdapter()
    expect(adapter.channelType).toBe('slack')
  })
})