Skip to content

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

TypeScript
22.1 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
import express from 'express'
import request from 'supertest'
import { createRpcRouter } from '../src/routes/rpc.js'

const authTokenMock = vi.hoisted(() => ({
  verifyRpcToken: vi.fn(),
}))

const serviceMock = vi.hoisted(() => ({
  listAllowedServersForUser: vi.fn(),
  resolveServerConnectionForUser: vi.fn(),
  resolveHostConnectionForUser: vi.fn(),
  validateRpcRequest: vi.fn(),
  forwardRpcToServer: vi.fn(),
  forwardHostMessageToHost: vi.fn(),
  forwardHostActivity: vi.fn(),
  forwardHostStatus: vi.fn(),
  forwardHostHealth: vi.fn(),
}))

const controlApiMock = vi.hoisted(() => ({
  ControlApiHostAccessRejectedError: class ControlApiHostAccessRejectedError extends Error {
    constructor(
      public readonly status: number,
      public readonly denialCode: string | null = null
    ) {
      super(`Control API rejected host access (${status})`)
      this.name = 'ControlApiHostAccessRejectedError'
    }
  },
  requestHostWakeFromControlApi: vi.fn(),
}))

vi.mock('../src/authToken.js', () => authTokenMock)
vi.mock('../src/services/mcpProxyService.js', () => serviceMock)
vi.mock('../src/services/controlApiRestService.js', () => controlApiMock)

describe('routes/rpc', () => {
  beforeEach(() => {
    authTokenMock.verifyRpcToken.mockReset()
    serviceMock.listAllowedServersForUser.mockReset()
    serviceMock.resolveServerConnectionForUser.mockReset()
    serviceMock.resolveHostConnectionForUser.mockReset()
    serviceMock.validateRpcRequest.mockReset()
    serviceMock.forwardRpcToServer.mockReset()
    serviceMock.forwardHostMessageToHost.mockReset()
    serviceMock.forwardHostActivity.mockReset()
    serviceMock.forwardHostStatus.mockReset()
    serviceMock.forwardHostHealth.mockReset()
    controlApiMock.requestHostWakeFromControlApi.mockReset()
  })

  function makeApp() {
    const app = express()
    app.use(express.json())
    app.use(createRpcRouter())
    return app
  }

  it('rejects list servers without token', async () => {
    const app = makeApp()
    await request(app).get('/rpc/servers').expect(401)
  })

  it('rejects invoke without mcp:server:invoke scope', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['mcp:servers:list'],
      hostRefs: ['mongodb-server'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })

    const app = makeApp()
    await request(app)
      .post('/rpc/mongodb-server')
      .set('authorization', 'Bearer token')
      .send({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} })
      .expect(403)
  })

  it('returns 400 for invalid JSON-RPC payload', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['mcp:server:invoke'],
      hostRefs: ['mongodb-server'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveServerConnectionForUser.mockResolvedValue({
      name: 'mongodb-server',
      url: 'http://mongodb-server/mcp',
      headers: {},
    })
    serviceMock.validateRpcRequest.mockReturnValue(null)

    const app = makeApp()
    await request(app)
      .post('/rpc/mongodb-server')
      .set('authorization', 'Bearer token')
      .send({ bad: true })
      .expect(400)
      .expect({ error: 'Invalid JSON-RPC request payload' })
  })

  it('forwards invoke and returns JSON-RPC response', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['mcp:servers:list', 'mcp:server:invoke'],
      hostRefs: ['mongodb-server'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveServerConnectionForUser.mockResolvedValue({
      name: 'mongodb-server',
      url: 'http://mongodb-server/mcp',
      headers: {},
    })
    serviceMock.validateRpcRequest.mockReturnValue({
      jsonrpc: '2.0',
      id: 1,
      method: 'tools/list',
      params: {},
    })
    serviceMock.forwardRpcToServer.mockResolvedValue({
      jsonrpc: '2.0',
      id: 1,
      result: { tools: [{ name: 'listCollections' }] },
    })

    const app = makeApp()
    const response = await request(app)
      .post('/rpc/mongodb-server')
      .set('authorization', 'Bearer token')
      .send({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} })
      .expect(200)

    expect(response.body).toEqual({
      jsonrpc: '2.0',
      id: 1,
      result: { tools: [{ name: 'listCollections' }] },
    })
    expect(serviceMock.resolveServerConnectionForUser).toHaveBeenCalledWith(
      'user-1',
      'mongodb-server',
      'token'
    )
  })

  it('rejects host message invoke without host:message:invoke scope', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['mcp:server:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    const app = makeApp()
    await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({ content: 'hi', channelType: 'rpc', sender: 'desktop-app' })
      .expect(403)
  })

  it('returns 400 when host payload is invalid', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    const app = makeApp()
    await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({ method: 'tools/list' })
      .expect(400)
  })

  it('forwards host message invoke and returns REST response', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostMessageToHost.mockResolvedValue({
      success: true,
      response: 'pong',
    })

    const app = makeApp()
    const response = await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({
        content: 'ping',
        channelType: 'rpc',
        sender: 'desktop-app',
      })
      .expect(200)

    expect(response.body).toEqual({
      success: true,
      response: 'pong',
    })
    expect(serviceMock.resolveHostConnectionForUser).toHaveBeenCalledWith(
      'user-1',
      'agent2',
      'token',
      {
        teamId: 'team-1',
      }
    )
  })

  it('resolves and binds through the canonical host-access call before forwarding a session request', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostMessageToHost.mockResolvedValue({ success: true, response: 'pong' })

    await request(makeApp())
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer rpc-token')
      .set('idempotency-key', 'delivery-1')
      .send({ content: 'ping', threadId: 'session-1' })
      .expect(200)

    expect(serviceMock.resolveHostConnectionForUser).toHaveBeenCalledWith(
      'user-1',
      'agent2',
      'rpc-token',
      {
        teamId: 'team-1',
        directRunBinding: {
          runId: expect.any(String),
          sessionId: 'session-1',
          origin: 'direct_chat',
        },
      }
    )
    expect(serviceMock.resolveHostConnectionForUser.mock.invocationCallOrder[0]).toBeLessThan(
      serviceMock.forwardHostMessageToHost.mock.invocationCallOrder[0]
    )
    const forwarded = serviceMock.forwardHostMessageToHost.mock.calls[0][1]
    expect(forwarded.traceContext).toEqual({
      version: 1,
      runId: expect.any(String),
      sessionId: 'session-1',
      origin: 'direct_chat',
      correlationRefs: expect.any(Array),
    })
    expect(forwarded.traceContext).not.toHaveProperty('userId')
    expect(forwarded.traceContext).not.toHaveProperty('actorHumanSub')
    expect(forwarded.traceContext).not.toHaveProperty('teamId')
  })

  it.each([
    [401, null, { error: 'Unauthorized' }],
    [
      403,
      'host_access_revoked',
      { error: 'Forbidden: user cannot access this host', code: 'host_access_revoked' },
    ],
    [
      403,
      'host_access_denied',
      { error: 'Forbidden: user cannot access this host', code: 'host_access_denied' },
    ],
    [409, null, { error: 'Direct run attribution conflict' }],
  ] as const)(
    'preserves a Control API %s (%s) from atomic host resolution and never forwards',
    async (status, denialCode, expectedBody) => {
      authTokenMock.verifyRpcToken.mockReturnValue({
        sub: 'user-1',
        typ: 'user',
        accessScope: 'team',
        teamId: 'team-1',
        scopes: ['host:message:invoke'],
        hostRefs: ['agent2'],
        jti: 'j1',
        iat: 1,
        exp: 9999999999,
      })
      serviceMock.resolveHostConnectionForUser.mockRejectedValue(
        new controlApiMock.ControlApiHostAccessRejectedError(status, denialCode)
      )

      await request(makeApp())
        .post('/rpc/hosts/agent2/messages')
        .set('authorization', 'Bearer rpc-token')
        .send({ content: 'ping', threadId: 'session-1' })
        .expect(status)
        .expect(expectedBody)

      expect(serviceMock.forwardHostMessageToHost).not.toHaveBeenCalled()
    }
  )

  it('preserves the request when the bounded binding write is transiently unavailable', async () => {
    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
      attributionBindingStatus: 'unavailable',
    })
    serviceMock.forwardHostMessageToHost.mockResolvedValue({ success: true, response: 'pong' })

    await request(makeApp())
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer rpc-token')
      .send({ content: 'ping', threadId: 'session-1' })
      .expect(200)

    expect(serviceMock.forwardHostMessageToHost).toHaveBeenCalledOnce()
    expect(warn).toHaveBeenCalledOnce()
    const signal = String(warn.mock.calls[0]?.[0])
    expect(JSON.parse(signal)).toEqual({
      event: 'governed_trace_operational_error',
      scope: 'agent_run',
      reason: 'attribution_binding_unavailable',
    })
    expect(signal).not.toMatch(/user-1|agent2|session-1|ping|rpc-token|runId/)
  })

  describe('image attachments shape', () => {
    beforeEach(() => {
      authTokenMock.verifyRpcToken.mockReturnValue({
        sub: 'user-1',
        typ: 'user',
        accessScope: 'team',
        teamId: 'team-1',
        scopes: ['host:message:invoke'],
        hostRefs: ['agent2'],
        jti: 'j1',
        iat: 1,
        exp: 9999999999,
      })
      serviceMock.resolveHostConnectionForUser.mockResolvedValue({
        name: 'agent2',
        url: 'http://agent2.mcp-host.svc.cluster.local:8080',
        headers: {},
      })
      serviceMock.forwardHostMessageToHost.mockResolvedValue({ success: true, response: 'pong' })
    })

    it('returns 400 invalid_attachments when attachments is not a list', async () => {
      await request(makeApp())
        .post('/rpc/hosts/agent2/messages')
        .set('authorization', 'Bearer rpc-token')
        .send({ content: 'hi', attachments: 'nope' })
        .expect(400)
        .expect({ error: 'invalid_attachments', message: 'Attachments must be a list.' })

      // Witness: the request was authenticated. The shape is rejected before
      // host resolution, so a malformed request never writes a binding.
      expect(authTokenMock.verifyRpcToken).toHaveBeenCalledOnce()
      expect(serviceMock.resolveHostConnectionForUser).toHaveBeenCalledTimes(0)
      expect(serviceMock.forwardHostMessageToHost).toHaveBeenCalledTimes(0)
    })

    it('forwards an empty attachments list', async () => {
      await request(makeApp())
        .post('/rpc/hosts/agent2/messages')
        .set('authorization', 'Bearer rpc-token')
        .send({ content: 'hi', attachments: [] })
        .expect(200)

      expect(serviceMock.forwardHostMessageToHost).toHaveBeenCalledOnce()
      expect(serviceMock.forwardHostMessageToHost.mock.calls[0][1]).toMatchObject({
        content: 'hi',
        attachments: [],
      })
    })

    it('forwards a non-empty image attachments list unchanged', async () => {
      const attachments = [
        {
          kind: 'image',
          mimeType: 'image/png',
          encoding: 'base64',
          dataBase64: 'iVBORw0KGgo=',
          id: 'a',
        },
      ]
      await request(makeApp())
        .post('/rpc/hosts/agent2/messages')
        .set('authorization', 'Bearer rpc-token')
        .send({ content: 'hi', attachments })
        .expect(200)

      expect(serviceMock.forwardHostMessageToHost).toHaveBeenCalledOnce()
      const forwarded = serviceMock.forwardHostMessageToHost.mock.calls[0][1]
      expect(forwarded.content).toBe('hi')
      expect(forwarded.attachments).toEqual(attachments)
    })
  })

  // Regression: the `forwardedBody` is an explicit field allow-list, so a new
  // client field is dropped unless threaded through. The R2 "Option A"
  // piggybacked per-session `model` was silently omitted — assert it now
  // survives the hop (trimmed), and that a blank value is omitted entirely.
  it('forwards the piggybacked per-session model (trimmed) to the host', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostMessageToHost.mockResolvedValue({ success: true, response: 'pong' })

    const app = makeApp()
    await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({ content: 'ping', channelType: 'rpc', sender: 'desktop-app', model: '  claude-x  ' })
      .expect(200)

    expect(serviceMock.forwardHostMessageToHost).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ model: 'claude-x' }),
      expect.anything()
    )
  })

  it('omits the model field when the piggybacked model is blank', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostMessageToHost.mockResolvedValue({ success: true, response: 'pong' })

    const app = makeApp()
    await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({ content: 'ping', channelType: 'rpc', sender: 'desktop-app', model: '   ' })
      .expect(200)

    const forwardedBody = serviceMock.forwardHostMessageToHost.mock.calls[0][1] as Record<
      string,
      unknown
    >
    expect(forwardedBody.model).toBeUndefined()
  })

  it('returns 502 when host message upstream fails', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostMessageToHost.mockRejectedValue(new Error('Upstream host returned 500'))
    const app = makeApp()
    const response = await request(app)
      .post('/rpc/hosts/agent2/messages')
      .set('authorization', 'Bearer token')
      .send({ content: 'hello', channelType: 'rpc', sender: 'desktop-app' })
      .expect(502)
    expect(response.body).toEqual({ error: 'Upstream host unavailable' })
  })

  it('forwards host status and returns sanitized payload', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:status:read'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      name: 'agent2',
      url: 'http://agent2.mcp-host.svc.cluster.local:8080',
      headers: {},
    })
    serviceMock.forwardHostStatus.mockResolvedValue({
      hostRef: 'agent2',
      agent: {
        state: 'idle',
        currentTaskId: null,
        tasksProcessed: 1,
        tasksSucceeded: 1,
        tasksFailed: 0,
        uptime: 1200,
      },
      queue: { pending: 0, processing: 0, completed: 1, failed: 0 },
      cronJobs: 0,
      pendingApprovalsCount: 0,
      observedAt: '2026-03-10T00:00:00.000Z',
    })
    const app = makeApp()
    const response = await request(app)
      .get('/rpc/hosts/agent2/status')
      .set('authorization', 'Bearer token')
      .expect(200)
    expect(response.body.hostRef).toBe('agent2')
    expect(serviceMock.resolveHostConnectionForUser).toHaveBeenCalledWith(
      'user-1',
      'agent2',
      'token',
      {
        teamId: 'team-1',
      }
    )
  })

  it('rejects host status without host:status:read scope', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    const app = makeApp()
    await request(app)
      .get('/rpc/hosts/agent2/status')
      .set('authorization', 'Bearer token')
      .expect(403)
  })

  it('rejects host activity without host:activity:read scope', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:status:read'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    const app = makeApp()
    await request(app)
      .get('/rpc/hosts/agent2/activity')
      .set('authorization', 'Bearer token')
      .expect(403)
  })

  it('rejects host health without host:health:read scope', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:status:read'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    const app = makeApp()
    await request(app)
      .get('/rpc/hosts/agent2/health')
      .set('authorization', 'Bearer token')
      .expect(403)
  })

  it('returns 403 for unauthorized host on host status', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:status:read'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      denied: true,
      code: 'host_access_denied',
    })
    const app = makeApp()
    await request(app)
      .get('/rpc/hosts/not-allowed/status')
      .set('authorization', 'Bearer token')
      .expect(403)
  })

  it('returns 403 for unauthorized host on host health', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:health:read'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      denied: true,
      code: 'host_access_denied',
    })
    const app = makeApp()
    await request(app)
      .get('/rpc/hosts/not-allowed/health')
      .set('authorization', 'Bearer token')
      .expect(403)
  })

  it('returns 403 for unauthorized host on host message invoke', async () => {
    authTokenMock.verifyRpcToken.mockReturnValue({
      sub: 'user-1',
      typ: 'user',
      accessScope: 'team',
      teamId: 'team-1',
      scopes: ['host:message:invoke'],
      hostRefs: ['agent2'],
      jti: 'j1',
      iat: 1,
      exp: 9999999999,
    })
    serviceMock.resolveHostConnectionForUser.mockResolvedValue({
      denied: true,
      code: 'host_access_denied',
    })
    const app = makeApp()
    await request(app)
      .post('/rpc/hosts/not-allowed/messages')
      .set('authorization', 'Bearer token')
      .send({ content: 'hi', channelType: 'rpc', sender: 'desktop-app' })
      .expect(403)
  })
})