Skip to content

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

TypeScript
17.6 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { createHash, createHmac } from 'node:crypto'
import request from 'supertest'
import { createApp } from '../src/app.js'
import { encodeSlackTargetId } from '../src/utils/slackTargetId.js'
import { encodeTeamsTargetId } from '../src/utils/teamsTargetId.js'
import { MockGateway } from './mockGateway.js'

const READER_TOKEN = 'dev-wa-reader-token'

const mockPoolQuery = vi.fn()
vi.mock('../src/db.js', () => ({
  pool: {
    query: (...args: unknown[]) => mockPoolQuery(...args),
  },
}))

afterEach(() => {
  vi.unstubAllGlobals()
})

function authedGet(
  app: ReturnType<typeof createApp>,
  path: string,
  token = READER_TOKEN,
  service = 'workflow-approval-reader'
) {
  return request(app)
    .get(path)
    .set('authorization', `Bearer ${token}`)
    .set('x-service-token', service)
}

function authedPost(
  app: ReturnType<typeof createApp>,
  path: string,
  body: unknown,
  token = READER_TOKEN,
  service = 'workflow-approval-reader'
) {
  return request(app)
    .post(path)
    .set('authorization', `Bearer ${token}`)
    .set('x-service-token', service)
    .send(body)
}

const UUID = '00000000-0000-4000-8000-000000000001'

function canApproveUrl(channelAlias: string) {
  return `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=telegram&providerUserId=12345&channelAlias=${channelAlias}`
}

function slackCanApproveUrl(channelAlias: string) {
  return `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=slack&providerUserId=U123&providerWorkspaceId=T123&providerChannelId=D123&channelAlias=${channelAlias}`
}

const REF_A = 'channels/cc-a'
// 16 hex / 64-bit channelAlias (matches CHANNEL_ALIAS_LEN).
const ALIAS_A = createHash('sha256').update(REF_A).digest('hex').slice(0, 16)

function b64(value: string): string {
  return Buffer.from(value, 'utf8').toString('base64')
}

function slackSignature(secret: string, timestamp: string, body: Buffer): string {
  return `v0=${createHmac('sha256', secret)
    .update(`v0:${timestamp}:${body.toString('utf8')}`)
    .digest('hex')}`
}

async function seedSlackTarget(
  gateway: MockGateway,
  overrides: { workspaceId?: string | null; name?: string } = {}
): Promise<string> {
  const name = overrides.name ?? 'slack-app'
  const workspaceId = overrides.workspaceId === undefined ? 'T123' : overrides.workspaceId
  await gateway.createResource(
    'communicationchannels',
    {
      metadata: { name },
      spec: {
        credentialsSecretRef: { name: 'slack-app-credentials' },
        hostRef: 'sandbox-recipes/agent-a',
        slackSettings: {
          replyInThreads: true,
          replyOnlyWhenMentioned: true,
          ...(workspaceId ? { workspaceId } : {}),
        },
      },
    },
    'channels'
  )
  gateway.seedSecret('slack-app-credentials', 'channels', {
    data: {
      'slack-bot-token': b64('xoxb-test-token'),
      'slack-signing-secret': b64('signing-secret'),
    },
  })
  return encodeSlackTargetId('channels', name)
}

async function seedTeamsTarget(
  gateway: MockGateway,
  overrides: { tenantId?: string | null; name?: string } = {}
): Promise<string> {
  const name = overrides.name ?? 'teams-bot'
  const tenantId = overrides.tenantId === undefined ? 'tenant-1' : overrides.tenantId
  await gateway.createResource(
    'communicationchannels',
    {
      metadata: { name },
      spec: {
        credentialsSecretRef: { name: 'teams-app-credentials' },
        hostRef: 'sandbox-recipes/agent-a',
        teamsSettings: {
          appId: 'teams-app-1',
          appName: 'evenfire',
          replyOnlyWhenMentioned: true,
          ...(tenantId ? { tenantId } : {}),
        },
      },
    },
    'channels'
  )
  gateway.seedSecret('teams-app-credentials', 'channels', {
    data: {
      'teams-app-password': b64('teams-app-secret'),
    },
  })
  return encodeTeamsTargetId('channels', name)
}

describe('GET /api/v1/internal/workflow-approval-reader/approvals/:id/can-approve', () => {
  let app: ReturnType<typeof createApp>

  beforeEach(() => {
    mockPoolQuery.mockReset()
    const gateway = new MockGateway('sandbox-recipes')
    app = createApp(gateway as never)
  })

  it('returns 401 without service auth', async () => {
    await request(app).get(canApproveUrl(ALIAS_A)).expect(401)
  })

  it('returns 401 when the service identity is wrong (rpc-proxy token)', async () => {
    await authedGet(app, canApproveUrl(ALIAS_A), 'dev-rpc-proxy-token', 'rpc-proxy').expect(401)
  })

  it('returns 400 for an invalid approval id', async () => {
    const res = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/not-a-uuid/can-approve?medium=telegram&providerUserId=1&channelAlias=${ALIAS_A}`
    )
    expect(res.status).toBe(400)
    expect(res.body.error).toBe('invalid_approval_id')
  })

  it('returns 400 for an invalid channelAlias (wrong length)', async () => {
    const res = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=telegram&providerUserId=1&channelAlias=tooshort`
    )
    expect(res.status).toBe(400)
    expect(res.body.error).toBe('invalid_channel_alias')
  })

  it('returns 400 unsupported_medium for an unknown medium', async () => {
    const res = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=discord&providerUserId=12345&channelAlias=${ALIAS_A}`
    )
    expect(res.status).toBe(400)
    expect(res.body.error).toBe('unsupported_medium')
  })

  it('returns 400 when Slack workspace or channel is missing', async () => {
    const missingWorkspace = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=slack&providerUserId=U123&providerChannelId=D123&channelAlias=${ALIAS_A}`
    )
    expect(missingWorkspace.status).toBe(400)
    expect(missingWorkspace.body.error).toBe('slack_workspace_id_required')

    const missingChannel = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=slack&providerUserId=U123&providerWorkspaceId=T123&channelAlias=${ALIAS_A}`
    )
    expect(missingChannel.status).toBe(400)
    expect(missingChannel.body.error).toBe('provider_channel_id_required')
  })

  it('returns 400 provider_user_id_required when providerUserId is empty', async () => {
    const res = await authedGet(
      app,
      `/api/v1/internal/workflow-approval-reader/approvals/${UUID}/can-approve?medium=telegram&providerUserId=&channelAlias=${ALIAS_A}`
    )
    expect(res.status).toBe(400)
    expect(res.body.error).toBe('provider_user_id_required')
  })

  it('returns canApprove=false reason=approval_not_found when the request does not exist', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 })
    const res = await authedGet(app, canApproveUrl(ALIAS_A))
    expect(res.status).toBe(200)
    expect(res.body).toEqual({ canApprove: false, reason: 'approval_not_found' })
  })

  it('returns canApprove=false reason=approval_not_pending when already decided', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'approved', isExpired: false }] })
    const res = await authedGet(app, canApproveUrl(ALIAS_A))
    expect(res.body).toEqual({ canApprove: false, reason: 'approval_not_pending' })
  })

  it('returns canApprove=false reason=approval_expired', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'pending', isExpired: true }] })
    const res = await authedGet(app, canApproveUrl(ALIAS_A))
    expect(res.body).toEqual({ canApprove: false, reason: 'approval_expired' })
  })

  it('returns canApprove=false reason=account_not_verified when no wama row exists', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'pending', isExpired: false }] })
    mockPoolQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 })
    const res = await authedGet(app, canApproveUrl(ALIAS_A))
    expect(res.body).toEqual({ canApprove: false, reason: 'account_not_verified' })
  })

  it('returns canApprove=false reason=cross_bot_mismatch when alias does not match the account ref', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'pending', isExpired: false }] })
    // Account verified on cc-a, but the alias is from cc-b
    const aliasB = createHash('sha256').update('channels/cc-b').digest('hex').slice(0, 16)
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ communicationChannelRef: REF_A }] })
    const res = await authedGet(app, canApproveUrl(aliasB))
    expect(res.body).toEqual({ canApprove: false, reason: 'cross_bot_mismatch' })
  })

  it('returns canApprove=true when the approval is pending, the account is verified, and the alias matches', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'pending', isExpired: false }] })
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ communicationChannelRef: REF_A }] })
    const res = await authedGet(app, canApproveUrl(ALIAS_A))
    expect(res.status).toBe(200)
    expect(res.body).toEqual({ canApprove: true })
  })

  it('returns canApprove=true for Slack only when workspace, channel, and alias match', async () => {
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ status: 'pending', isExpired: false }] })
    mockPoolQuery.mockResolvedValueOnce({ rows: [{ communicationChannelRef: REF_A }] })
    const res = await authedGet(app, slackCanApproveUrl(ALIAS_A))
    expect(res.status).toBe(200)
    expect(res.body).toEqual({ canApprove: true })
    const [, params] = mockPoolQuery.mock.calls[1]!
    expect(params).toEqual(['slack', 'U123', 'T123', 'D123'])
  })
})

describe('GET /api/v1/internal/workflow-approval-reader/channel-ref', () => {
  let app: ReturnType<typeof createApp>
  let gateway: MockGateway

  beforeEach(async () => {
    mockPoolQuery.mockReset()
    gateway = new MockGateway('channels')
    await gateway.createResource(
      'communicationchannels',
      {
        metadata: { name: 'slack-a' },
        spec: {
          slack: [{ workspaceId: 'T123', channelId: 'D123', userIds: ['U123'] }],
          telegram: [{ channelId: '456', chatType: 'private', userIds: ['123'] }],
        },
      },
      'channels'
    )
    app = createApp(gateway as never)
  })

  it('resolves Slack provider workspace/channel to the CommunicationChannel ref', async () => {
    const res = await authedGet(
      app,
      '/api/v1/internal/workflow-approval-reader/channel-ref?medium=slack&providerWorkspaceId=T123&providerChannelId=D123'
    )
    expect(res.status).toBe(200)
    expect(res.body).toEqual({ communicationChannelRef: 'channels/slack-a' })
  })

  it('resolves Telegram provider channel to the CommunicationChannel ref', async () => {
    const res = await authedGet(
      app,
      '/api/v1/internal/workflow-approval-reader/channel-ref?medium=telegram&providerChannelId=456'
    )
    expect(res.status).toBe(200)
    expect(res.body).toEqual({ communicationChannelRef: 'channels/slack-a' })
  })

  it('fails closed when Slack channel resolution is ambiguous', async () => {
    await gateway.createResource(
      'communicationchannels',
      {
        metadata: { name: 'slack-b' },
        spec: {
          slack: [{ workspaceId: 'T123', channelId: 'D123', userIds: ['U456'] }],
        },
      },
      'channels'
    )

    const res = await authedGet(
      app,
      '/api/v1/internal/workflow-approval-reader/channel-ref?medium=slack&providerWorkspaceId=T123&providerChannelId=D123'
    )
    expect(res.status).toBe(409)
    expect(res.body).toEqual({ error: 'communication_channel_ambiguous' })
  })
})

describe('Slack target proxy routes', () => {
  let app: ReturnType<typeof createApp>
  let gateway: MockGateway
  let targetId: string

  beforeEach(async () => {
    mockPoolQuery.mockReset()
    gateway = new MockGateway('channels')
    targetId = await seedSlackTarget(gateway)
    app = createApp(gateway as never)
  })

  it('returns Slack response settings after verifying the target signature', async () => {
    const rawBody = Buffer.from(JSON.stringify({ type: 'event_callback', team_id: 'T123' }))
    const timestamp = `${Math.floor(Date.now() / 1000)}`
    const res = await authedPost(
      app,
      `/api/v1/internal/workflow-approval-reader/slack-targets/${encodeURIComponent(
        targetId
      )}/verify-signature`,
      {
        rawBodyBase64: rawBody.toString('base64'),
        signature: slackSignature('signing-secret', timestamp, rawBody),
        timestamp,
      }
    )

    expect(res.status).toBe(200)
    expect(res.body).toMatchObject({
      ok: true,
      communicationChannelRef: 'channels/slack-app',
      hostRef: 'sandbox-recipes/agent-a',
      providerWorkspaceId: 'T123',
      replyInThreads: true,
      replyOnlyWhenMentioned: true,
    })
  })

  it('infers the Slack workspace from a signed event when the target has none configured', async () => {
    const inferredTargetId = await seedSlackTarget(gateway, {
      name: 'slack-app-unbound',
      workspaceId: null,
    })
    const rawBody = Buffer.from(
      JSON.stringify({ type: 'event_callback', event: { team: 'T-INFERRED' } })
    )
    const timestamp = `${Math.floor(Date.now() / 1000)}`
    const res = await authedPost(
      app,
      `/api/v1/internal/workflow-approval-reader/slack-targets/${encodeURIComponent(
        inferredTargetId
      )}/verify-signature`,
      {
        rawBodyBase64: rawBody.toString('base64'),
        signature: slackSignature('signing-secret', timestamp, rawBody),
        timestamp,
      }
    )

    expect(res.status).toBe(200)
    expect(res.body).toMatchObject({
      ok: true,
      communicationChannelRef: 'channels/slack-app-unbound',
      providerWorkspaceId: 'T-INFERRED',
    })
  })

  it('updates Slack messages through the stored bot token', async () => {
    const fetchMock = vi.fn().mockResolvedValue({
      ok: true,
      status: 200,
      json: async () => ({ ok: true, ts: '1710000000.000002' }),
    } as Response)
    vi.stubGlobal('fetch', fetchMock)

    const res = await authedPost(
      app,
      `/api/v1/internal/workflow-approval-reader/slack-targets/${encodeURIComponent(
        targetId
      )}/update-message`,
      {
        channelId: 'C123',
        messageTs: '1710000000.000002',
        text: 'agent reply',
        blocks: [],
      }
    )

    expect(res.status).toBe(200)
    expect(res.body).toEqual({ ok: true, ts: '1710000000.000002' })
    expect(fetchMock).toHaveBeenCalledWith(
      expect.stringContaining('/chat.update'),
      expect.objectContaining({ method: 'POST' })
    )
    const init = fetchMock.mock.calls[0]?.[1] as RequestInit
    const headers = init.headers as Headers
    expect(headers.get('Authorization')).toBe('Bearer xoxb-test-token')
    expect(JSON.parse(String(init.body))).toEqual({
      blocks: [],
      channel: 'C123',
      text: 'agent reply',
      ts: '1710000000.000002',
    })
  })
})

describe('Teams target proxy routes', () => {
  let app: ReturnType<typeof createApp>
  let gateway: MockGateway
  let targetId: string

  beforeEach(async () => {
    mockPoolQuery.mockReset()
    gateway = new MockGateway('channels')
    targetId = await seedTeamsTarget(gateway)
    app = createApp(gateway as never)
  })

  it('updates Teams messages through the stored app credentials', async () => {
    const fetchMock = vi
      .fn()
      .mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({ access_token: 'teams-access-token' }),
      } as Response)
      .mockResolvedValueOnce({
        ok: true,
        status: 200,
        json: async () => ({ id: 'activity-1' }),
      } as Response)
    vi.stubGlobal('fetch', fetchMock)

    const res = await authedPost(
      app,
      `/api/v1/internal/workflow-approval-reader/teams-targets/${encodeURIComponent(
        targetId
      )}/update-message`,
      {
        conversationId: '19:[email protected]',
        messageId: 'activity-1',
        serviceUrl: 'https://smba.trafficmanager.net/amer/',
        text: 'Approved. Workflow approval recorded.',
      }
    )

    expect(res.status).toBe(200)
    expect(res.body).toEqual({ ok: true, id: 'activity-1' })
    expect(fetchMock).toHaveBeenCalledTimes(2)
    expect(fetchMock.mock.calls[0]?.[0]).toContain(
      'https://login.microsoftonline.com/tenant-1/oauth2/v2.0/token'
    )
    const tokenInit = fetchMock.mock.calls[0]?.[1] as RequestInit
    expect(String(tokenInit.body)).toContain('client_id=teams-app-1')
    expect(String(tokenInit.body)).toContain('client_secret=teams-app-secret')

    expect(fetchMock.mock.calls[1]?.[0]).toBe(
      'https://smba.trafficmanager.net/amer/v3/conversations/19%3Achannel-1%40thread.tacv2/activities/activity-1'
    )
    const updateInit = fetchMock.mock.calls[1]?.[1] as RequestInit
    const headers = updateInit.headers as Headers
    expect(headers.get('Authorization')).toBe('Bearer teams-access-token')
    expect(JSON.parse(String(updateInit.body))).toEqual({
      type: 'message',
      text: 'Approved. Workflow approval recorded.',
      attachments: [],
    })
  })

  it('rejects Teams message updates with unsupported service URLs', async () => {
    const fetchMock = vi.fn()
    vi.stubGlobal('fetch', fetchMock)

    const res = await authedPost(
      app,
      `/api/v1/internal/workflow-approval-reader/teams-targets/${encodeURIComponent(
        targetId
      )}/update-message`,
      {
        conversationId: '19:[email protected]',
        messageId: 'activity-1',
        serviceUrl: 'http://attacker.example.com',
        text: 'Approved. Workflow approval recorded.',
      }
    )

    expect(res.status).toBe(400)
    expect(res.body).toEqual({ error: 'invalid_teams_service_url' })
    expect(fetchMock).not.toHaveBeenCalled()
  })
})