Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { describe, expect, it, vi } from 'vitest'
import {
validateMcpServerSpec,
validateMcpServerSpecPreflight,
} from '../src/http/validateMcpServerSpec.js'
describe('validateMcpServerSpec', () => {
it('returns empty array for a valid minimal spec', () => {
const errors = validateMcpServerSpec({
image: 'my-server:latest',
transport: { type: 'streamableHttp' },
})
expect(errors).toEqual([])
})
describe('egressBindings', () => {
it('accepts exact-host and public-web egress bindings', () => {
const errors = validateMcpServerSpec({
egressBindings: [
{ dns: 'api.example.com', port: 443, protocol: 'TCP' },
{ egressClass: 'public-web' },
],
})
expect(errors).toEqual([])
})
it('rejects more than 20 egress bindings before Kubernetes', () => {
const errors = validateMcpServerSpec({
egressBindings: Array.from({ length: 21 }, (_, index) => ({
dns: `api-${index}.example.com`,
port: 443,
protocol: 'TCP',
})),
})
expect(errors).toContainEqual(
expect.objectContaining({
field: 'spec.egressBindings',
message: expect.stringContaining('at most 20'),
})
)
})
it('rejects public-web bindings that smuggle exact-host fields', () => {
const errors = validateMcpServerSpec({
egressBindings: [{ egressClass: 'public-web', dns: 'api.example.com', port: 443 }],
})
expect(errors).toContainEqual(
expect.objectContaining({
field: 'spec.egressBindings[0]',
message: expect.stringContaining('must not declare dns'),
})
)
})
it('rejects remote MCP specs without egress bindings before Kubernetes', () => {
const missing = validateMcpServerSpec({
remote: { baseUrl: 'https://api.vendor.example/mcp' },
})
const empty = validateMcpServerSpec({
remote: { baseUrl: 'https://api.vendor.example/mcp' },
egressBindings: [],
})
expect(missing).toContainEqual({
field: 'spec.egressBindings',
message: 'remote MCP servers must declare at least one egressBinding',
})
expect(empty).toContainEqual({
field: 'spec.egressBindings',
message: 'remote MCP servers must declare at least one egressBinding',
})
})
it('rejects exact-host dns values that target internal or metadata hostnames', () => {
const errors = validateMcpServerSpec({
egressBindings: [
{ dns: 'metadata.goog', port: 443 },
{ dns: 'api.internal', port: 443 },
{ dns: 'kubernetes.default.svc', port: 443 },
],
})
expect(errors).toEqual(
expect.arrayContaining([
expect.objectContaining({ field: 'spec.egressBindings[0].dns' }),
expect.objectContaining({ field: 'spec.egressBindings[1].dns' }),
expect.objectContaining({ field: 'spec.egressBindings[2].dns' }),
])
)
})
it('preflights cidr bindings against the public IPv4 allow rules', () => {
const valid = validateMcpServerSpec({
egressBindings: [{ cidr: '8.8.8.8/32', port: 443 }],
})
expect(valid).toEqual([])
const invalid = validateMcpServerSpec({
egressBindings: [
{ cidr: '10.0.0.0/8', port: 443 },
{ cidr: '203.0.113.1/32', port: 443 },
{ cidr: '2001:db8::/32', port: 443 },
{ cidr: '8.8.8.1/24', port: 443 },
],
})
expect(invalid).toEqual(
expect.arrayContaining([
expect.objectContaining({ field: 'spec.egressBindings[0].cidr' }),
expect.objectContaining({ field: 'spec.egressBindings[1].cidr' }),
expect.objectContaining({ field: 'spec.egressBindings[2].cidr' }),
expect.objectContaining({ field: 'spec.egressBindings[3].cidr' }),
])
)
})
it('preflight resolves each exact-host DNS name once and accepts public IPv4 answers', async () => {
const resolveDns = vi.fn(async () => ['93.184.216.34'])
const errors = await validateMcpServerSpecPreflight(
{
egressBindings: [
{ dns: 'api.example.com', port: 443 },
{ dns: 'api.example.com', port: 80 },
],
},
{ resolveDns }
)
expect(errors).toEqual([])
expect(resolveDns).toHaveBeenCalledTimes(1)
expect(resolveDns).toHaveBeenCalledWith('api.example.com')
})
it('preflight rejects unresolved and blocked or mixed exact-host DNS answers', async () => {
const resolveDns = vi.fn(async (hostname: string) => {
if (hostname === 'unresolved.example.com') return []
if (hostname === 'metadata.example.com') return ['169.254.169.254']
return ['93.184.216.34', '10.0.0.5']
})
const errors = await validateMcpServerSpecPreflight(
{
egressBindings: [
{ dns: 'unresolved.example.com', port: 443 },
{ dns: 'metadata.example.com', port: 443 },
{ dns: 'mixed.example.com', port: 443 },
{ egressClass: 'public-web' },
],
},
{ resolveDns }
)
expect(errors).toEqual(
expect.arrayContaining([
expect.objectContaining({
field: 'spec.egressBindings[0].dns',
message: expect.stringContaining('did not resolve'),
}),
expect.objectContaining({
field: 'spec.egressBindings[1].dns',
message: expect.stringContaining('169.254.169.254'),
}),
expect.objectContaining({
field: 'spec.egressBindings[2].dns',
message: expect.stringContaining('10.0.0.5'),
}),
])
)
expect(resolveDns).not.toHaveBeenCalledWith(expect.stringContaining('public-web'))
})
})
it('returns empty array for an empty spec', () => {
const errors = validateMcpServerSpec({})
expect(errors).toEqual([])
})
// ── imagePullPolicy: platform-controlled ─────────────────────────────────────
describe('imagePullPolicy', () => {
it('rejects imagePullPolicy when set', () => {
const errors = validateMcpServerSpec({ imagePullPolicy: 'Always' })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.imagePullPolicy')
expect(errors[0].message).toContain('platform-controlled')
})
it('rejects imagePullPolicy even with valid value', () => {
const errors = validateMcpServerSpec({ imagePullPolicy: 'IfNotPresent' })
expect(errors).toHaveLength(1)
})
})
// ── Security: runAsUser ─────────────────────────────────────────────────────
describe('security.runAsUser', () => {
it('allows runAsUser >= 1', () => {
const errors = validateMcpServerSpec({ security: { runAsUser: 1000 } })
expect(errors).toEqual([])
})
it('rejects runAsUser = 0 (root)', () => {
const errors = validateMcpServerSpec({ security: { runAsUser: 0 } })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.security.runAsUser')
expect(errors[0].message).toContain('must be >= 1')
})
it('rejects negative runAsUser', () => {
const errors = validateMcpServerSpec({ security: { runAsUser: -1 } })
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('-1')
})
})
// ── Security: Linux capabilities ────────────────────────────────────────────
describe('security.addCapabilities', () => {
it('allows safe capabilities', () => {
const errors = validateMcpServerSpec({
security: {
addCapabilities: ['CHOWN', 'FOWNER', 'DAC_OVERRIDE', 'NET_BIND_SERVICE'],
},
})
expect(errors).toEqual([])
})
it('rejects privilege-boundary capabilities', () => {
const deniedCapabilities = ['SETUID', 'SETGID', 'SYS_CHROOT', 'KILL', 'AUDIT_WRITE']
const errors = validateMcpServerSpec({
security: { addCapabilities: deniedCapabilities },
})
expect(errors).toHaveLength(1)
deniedCapabilities.forEach(cap => {
expect(errors[0].message).toContain(cap)
})
})
it('rejects SYS_ADMIN', () => {
const errors = validateMcpServerSpec({ security: { addCapabilities: ['SYS_ADMIN'] } })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.security.addCapabilities')
expect(errors[0].message).toContain('SYS_ADMIN')
})
it('rejects multiple capabilities outside the default-allowed set at once', () => {
const errors = validateMcpServerSpec({
security: { addCapabilities: ['SYS_ADMIN', 'NET_ADMIN', 'SYS_PTRACE'] },
})
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('SYS_ADMIN')
expect(errors[0].message).toContain('NET_ADMIN')
expect(errors[0].message).toContain('SYS_PTRACE')
})
it('performs case-insensitive capability check', () => {
const errors = validateMcpServerSpec({ security: { addCapabilities: ['sys_admin'] } })
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('sys_admin')
})
it('rejects unknown capabilities instead of relying only on a forbidden list', () => {
const errors = validateMcpServerSpec({ security: { addCapabilities: ['SYS_NICE'] } })
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('SYS_NICE')
})
})
// ── Environment variables ───────────────────────────────────────────────────
describe('env vars', () => {
it('allows safe env vars', () => {
const errors = validateMcpServerSpec({
env: [
{ name: 'MY_API_KEY', value: 'secret' },
{ name: 'NODE_ENV', value: 'production' },
],
})
expect(errors).toEqual([])
})
it('rejects LD_PRELOAD', () => {
const errors = validateMcpServerSpec({ env: [{ name: 'LD_PRELOAD', value: '/evil.so' }] })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.env')
expect(errors[0].message).toContain('LD_PRELOAD')
})
it('rejects KUBECONFIG', () => {
const errors = validateMcpServerSpec({
env: [{ name: 'KUBECONFIG', value: '/etc/kubernetes/admin.conf' }],
})
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('KUBECONFIG')
})
it('rejects multiple dangerous env vars at once', () => {
const errors = validateMcpServerSpec({
env: [
{ name: 'PATH', value: '/evil' },
{ name: 'LD_LIBRARY_PATH', value: '/evil' },
],
})
expect(errors).toHaveLength(1)
expect(errors[0].message).toContain('PATH')
expect(errors[0].message).toContain('LD_LIBRARY_PATH')
})
it('performs case-insensitive env var check', () => {
const errors = validateMcpServerSpec({ env: [{ name: 'path', value: '/evil' }] })
expect(errors).toHaveLength(1)
})
})
// ── Resource limits ─────────────────────────────────────────────────────────
describe('resource limits', () => {
it('allows CPU within limits', () => {
const errors = validateMcpServerSpec({ resources: { limits: { cpu: '2000m' } } })
expect(errors).toEqual([])
})
it('rejects CPU exceeding 4000m', () => {
const errors = validateMcpServerSpec({ resources: { limits: { cpu: '8000m' } } })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.resources.limits.cpu')
expect(errors[0].message).toContain('8000m')
})
it('rejects CPU exceeding limit in cores (8 = 8000m)', () => {
const errors = validateMcpServerSpec({ resources: { limits: { cpu: '8' } } })
expect(errors).toHaveLength(1)
})
it('allows memory within limits', () => {
const errors = validateMcpServerSpec({ resources: { limits: { memory: '4Gi' } } })
expect(errors).toEqual([])
})
it('rejects memory exceeding 8Gi', () => {
const errors = validateMcpServerSpec({ resources: { limits: { memory: '16Gi' } } })
expect(errors).toHaveLength(1)
expect(errors[0].field).toBe('spec.resources.limits.memory')
expect(errors[0].message).toContain('16Gi')
})
it('handles memory in Mi notation', () => {
const errors = validateMcpServerSpec({ resources: { limits: { memory: '4096Mi' } } })
expect(errors).toEqual([])
})
it('rejects memory in Mi exceeding limit', () => {
const errors = validateMcpServerSpec({ resources: { limits: { memory: '16384Mi' } } })
expect(errors).toHaveLength(1)
})
})
// ── Multiple errors at once ─────────────────────────────────────────────────
it('collects multiple errors from different fields', () => {
const errors = validateMcpServerSpec({
imagePullPolicy: 'Always',
security: { runAsUser: 0, addCapabilities: ['SYS_ADMIN'] },
env: [{ name: 'KUBECONFIG', value: '/evil' }],
resources: { limits: { cpu: '8000m', memory: '16Gi' } },
})
// imagePullPolicy + runAsUser + addCapabilities + env + cpu + memory = 6 errors
expect(errors.length).toBeGreaterThanOrEqual(5)
const fields = errors.map(e => e.field)
expect(fields).toContain('spec.imagePullPolicy')
expect(fields).toContain('spec.security.runAsUser')
expect(fields).toContain('spec.security.addCapabilities')
expect(fields).toContain('spec.env')
})
})
describe('plugin image allowlist pre-check (2.3)', () => {
const opts = {
allowedImagePrefixes: ['registry.evenfire.ai/', 'clerum/'],
enforceImageAllowlist: true,
}
it('enforce: local disallowed image → spec.image error', () => {
const errors = validateMcpServerSpec({ image: 'docker.io/evil/x:1' }, opts)
expect(errors.some(e => e.field === 'spec.image')).toBe(true)
})
it('enforce: local allowed image → no image error', () => {
const errors = validateMcpServerSpec({ image: 'registry.evenfire.ai/a/x:1' }, opts)
expect(errors.some(e => e.field === 'spec.image')).toBe(false)
})
it('audit (enforce off): disallowed image → no image error', () => {
const errors = validateMcpServerSpec(
{ image: 'docker.io/evil/x:1' },
{ allowedImagePrefixes: ['registry.evenfire.ai/'], enforceImageAllowlist: false }
)
expect(errors.some(e => e.field === 'spec.image')).toBe(false)
})
it('enforce: remote-mode spec is exempt even with a disallowed image', () => {
const errors = validateMcpServerSpec(
{
image: 'docker.io/evil/x:1',
remote: { baseUrl: 'https://x.example.com/mcp' },
egressBindings: [{ dns: 'x.example.com', port: 443, protocol: 'TCP' }],
},
opts
)
expect(errors.some(e => e.field === 'spec.image')).toBe(false)
})
it('enforce: missing image → no image-allowlist error (no-op)', () => {
const errors = validateMcpServerSpec({ egressBindings: [] }, opts)
expect(errors.some(e => e.field === 'spec.image')).toBe(false)
})
})