Skip to content

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

TypeScript
5.9 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import {
  MCP_SECRET_ROLLBACK_CLAIM_TTL_SECONDS,
  MCP_SECRET_ROLLBACK_PERMIT_TTL_SECONDS,
  claimMcpSecretRollbackPermit,
  finalizeMcpSecretRollbackPermitClaim,
  issueMcpSecretRollbackPermit,
  releaseMcpSecretRollbackPermitClaim,
} from '../src/services/mcpSecretRollbackPermitService.js'

const permit = {
  sessionJti: 'admin-session-jti-raw',
  name: 'linear-credentials',
  namespace: 'mcp-server',
  uid: 'uid-linear',
  resourceVersion: '7',
}

describe('mcpSecretRollbackPermitService', () => {
  it('rejects incomplete permits before querying PostgreSQL', async () => {
    const query = vi.fn()

    await expect(
      issueMcpSecretRollbackPermit({ ...permit, sessionJti: '' }, { query } as never)
    ).rejects.toThrow('invalid_mcp_secret_rollback_permit')
    expect(query).not.toHaveBeenCalled()
  })

  it('stores only a hash of the admin session and a bounded resource identity', async () => {
    const query = vi
      .fn()
      .mockResolvedValueOnce({ rows: [], rowCount: 0 })
      .mockResolvedValueOnce({ rows: [], rowCount: 1 })

    await issueMcpSecretRollbackPermit(permit, { query } as never)

    const insert = query.mock.calls.find(([sql]) =>
      String(sql).includes('INSERT INTO mcp_secret_rollback_permits')
    )
    expect(insert).toBeDefined()
    expect(insert?.[1]).toEqual([
      expect.any(Buffer),
      'mcp-server',
      'linear-credentials',
      'uid-linear',
      '7',
      MCP_SECRET_ROLLBACK_PERMIT_TTL_SECONDS,
    ])
    expect((insert?.[1] as unknown[])[0]).toHaveLength(32)
    const cleanupSql = String(query.mock.calls[0]?.[0])
    expect(cleanupSql).toContain('LIMIT 100')
    expect(String(insert?.[0])).toContain('claim_token = NULL')
    expect(String(insert?.[0])).toContain('claim_expires_at = NULL')
    expect(JSON.stringify(query.mock.calls)).not.toContain(permit.sessionJti)
  })

  it('atomically claims an unexpired permit for the same session and resource name', async () => {
    const query = vi.fn().mockResolvedValueOnce({
      rows: [
        {
          uid: 'uid-linear',
          resourceVersion: '7',
          claimToken: '11111111-1111-4111-8111-111111111111',
        },
      ],
      rowCount: 1,
    })

    const result = await claimMcpSecretRollbackPermit(
      {
        sessionJti: permit.sessionJti,
        name: permit.name,
        namespace: permit.namespace,
      },
      { query } as never
    )

    expect(result).toEqual({
      uid: 'uid-linear',
      resourceVersion: '7',
      claimToken: '11111111-1111-4111-8111-111111111111',
    })
    const sql = String(query.mock.calls[0]?.[0])
    expect(sql).toContain('UPDATE mcp_secret_rollback_permits')
    expect(sql).toContain('expires_at > statement_timestamp()')
    expect(sql).toContain('claim_expires_at <= statement_timestamp()')
    expect(sql).toContain('RETURNING uid')
    expect(query.mock.calls[0]?.[1]).toEqual([
      expect.any(Buffer),
      'mcp-server',
      'linear-credentials',
      expect.stringMatching(/^[0-9a-f-]{36}$/),
      MCP_SECRET_ROLLBACK_CLAIM_TTL_SECONDS,
    ])
    expect(query).toHaveBeenCalledOnce()
    expect(JSON.stringify(query.mock.calls)).not.toContain(permit.sessionJti)
  })

  it('returns null when no active permit exists', async () => {
    const query = vi.fn().mockResolvedValueOnce({ rows: [], rowCount: 0 })

    await expect(
      claimMcpSecretRollbackPermit(
        {
          sessionJti: permit.sessionJti,
          name: permit.name,
          namespace: permit.namespace,
        },
        { query } as never
      )
    ).resolves.toBeNull()
  })

  it('releases only the matching claim so a transient failure can retry', async () => {
    const query = vi.fn().mockResolvedValueOnce({ rows: [], rowCount: 1 })
    await releaseMcpSecretRollbackPermitClaim(
      {
        sessionJti: permit.sessionJti,
        namespace: permit.namespace,
        name: permit.name,
        claimToken: '11111111-1111-4111-8111-111111111111',
      },
      { query } as never
    )
    const sql = String(query.mock.calls[0]?.[0])
    expect(sql).toContain('SET claim_token = NULL')
    expect(sql).toContain('claim_token = $4')
    // The SQL text alone proves nothing about what $1..$4 carry: the release
    // must be bound to the hashed session, the exact resource, and the claim
    // token that was handed out, and the raw session JTI must never be a
    // parameter (it would land in pg logs and slow-query captures).
    expect(query.mock.calls[0]?.[1]).toEqual([
      expect.any(Buffer),
      'mcp-server',
      'linear-credentials',
      '11111111-1111-4111-8111-111111111111',
    ])
    expect((query.mock.calls[0]?.[1] as unknown[])[0]).toHaveLength(32)
    expect(query).toHaveBeenCalledOnce()
    expect(JSON.stringify(query.mock.calls)).not.toContain(permit.sessionJti)
  })

  it('finalizes only the matching claim after a terminal result', async () => {
    const query = vi.fn().mockResolvedValueOnce({ rows: [], rowCount: 1 })
    await finalizeMcpSecretRollbackPermitClaim(
      {
        sessionJti: permit.sessionJti,
        namespace: permit.namespace,
        name: permit.name,
        claimToken: '11111111-1111-4111-8111-111111111111',
      },
      { query } as never
    )
    const sql = String(query.mock.calls[0]?.[0])
    expect(sql).toContain('DELETE FROM mcp_secret_rollback_permits')
    expect(sql).toContain('claim_token = $4')
    // Same binding proof as release: a finalize that matched on anything
    // broader than (session hash, namespace, name, claim token) could delete a
    // permit another admin session still needs for its own rollback.
    expect(query.mock.calls[0]?.[1]).toEqual([
      expect.any(Buffer),
      'mcp-server',
      'linear-credentials',
      '11111111-1111-4111-8111-111111111111',
    ])
    expect((query.mock.calls[0]?.[1] as unknown[])[0]).toHaveLength(32)
    expect(query).toHaveBeenCalledOnce()
    expect(JSON.stringify(query.mock.calls)).not.toContain(permit.sessionJti)
  })
})