Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { afterEach, describe, expect, it, vi } from 'vitest'
import { Readable } from 'node:stream'
import { McpServerProvider } from './k8sClient'
import { McpApiAuthenticator, type VerifiedMcpHostPrincipal } from './mcpApiAuthentication'
import {
type AuthorityContext,
type AuthorityHost,
type AuthorityMcpServer,
type AuthoritySecret,
McpAuthorizationError,
McpAuthorizationService,
type McpAuthorizationStore,
} from './mcpAuthorization'
import {
type ReadinessInventoryDetail,
resolveHostAuthoritativeFn,
resolveProbeAuthoritativeFn,
resolveProviderAuthoritativeFn,
resolveReadinessDetailFn,
} from './readinessGate'
import { ContextMapperServer, McpHostApiRateLimiter } from './server'
import type { McpServerInfo } from './types'
class FakeProvider implements McpServerProvider {
constructor(private readonly infos: McpServerInfo[] = []) {}
getAllServers() {
return []
}
getAllServerInfos() {
return this.infos
}
async getServerInfosByContext() {
return []
}
onChange() {}
async start() {}
async stop() {}
}
class MockResponse {
statusCode = 200
headers: Record<string, string> = {}
body = ''
headersSent = false
setHeader(name: string, value: string): void {
this.headers[name] = value
}
writeHead(status: number, headers?: Record<string, string>): void {
this.statusCode = status
this.headersSent = true
if (headers) Object.assign(this.headers, headers)
}
end(chunk?: string): void {
if (chunk) this.body += chunk
}
}
async function invoke(
server: ContextMapperServer,
path: string,
options: { method?: string; headers?: Record<string, string>; body?: string } = {}
) {
const headers = options.headers ?? {}
const req = Readable.from(options.body === undefined ? [] : [options.body])
Object.assign(req, {
method: options.method ?? 'GET',
url: path,
headers,
rawHeaders: Object.entries(headers).flatMap(([name, value]) => [name, value]),
})
const res = new MockResponse()
await (
server as unknown as {
handleRequest: (req: Readable, res: MockResponse) => Promise<void>
}
).handleRequest(req, res)
return res
}
const principal: VerifiedMcpHostPrincipal = {
subject: 'mcp-host/standalone',
hostName: 'host-a',
hostUid: 'host-uid-a',
namespace: 'mcp-host',
jti: 'jti-a',
issuedAt: 1,
expiresAt: 4_000_000_000,
audiences: ['host-context-controller'],
}
class FakeAuthorityStore implements McpAuthorizationStore {
secretValueReads = 0
private readonly host: AuthorityHost = {
name: 'host-a',
namespace: 'mcp-host',
metadata: { uid: 'host-uid-a', resourceVersion: '1' },
contextRef: 'context-a',
}
private readonly context: AuthorityContext = {
name: 'context-a',
namespace: 'mcp-server',
metadata: { uid: 'context-uid-a', resourceVersion: '2' },
mcpServers: ['server-a'],
}
private readonly mcpServer: AuthorityMcpServer = {
name: 'server-a',
namespace: 'mcp-server',
metadata: { uid: 'server-uid-a', resourceVersion: '3' },
transport: { type: 'streamableHttp', url: 'http://server-a/mcp' },
auth: { type: 'bearer', secretRef: 'server-a-auth', secretKey: 'token' },
enabled: true,
status: { deployed: true, ready: true },
}
private readonly secret: AuthoritySecret = {
name: 'server-a-auth',
namespace: 'mcp-server',
metadata: { uid: 'secret-uid-a', resourceVersion: '4' },
data: { token: Buffer.from('credential-value').toString('base64') },
}
async readHost() {
return this.host
}
async readContext() {
return this.context
}
async readMcpServer() {
return this.mcpServer
}
async readSecretMetadata() {
return {
name: this.secret.name,
namespace: this.secret.namespace,
metadata: this.secret.metadata,
}
}
async readSecret() {
this.secretValueReads += 1
return this.secret
}
}
function protectedServer(store = new FakeAuthorityStore()): {
server: ContextMapperServer
store: FakeAuthorityStore
} {
const authenticator = { authenticate: () => principal } as unknown as McpApiAuthenticator
const server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => true,
() => true,
authenticator,
new McpAuthorizationService(store)
)
server.setReady(true)
return { server, store }
}
describe('ContextMapperServer', () => {
let server: ContextMapperServer | null = null
afterEach(async () => {
await server?.stop()
server = null
vi.restoreAllMocks()
})
it('withholds readiness when no inventory-authority gate is wired', async () => {
// The gate decides whether the provider's inventory is authoritative. A
// caller that forgets to wire it must not get a permanently Ready server:
// this endpoint is the contract that no stale allow is live, so the default
// has to fail closed. There is no type error to catch the omission.
server = new ContextMapperServer(new FakeProvider(), 0)
server.setReady(true)
const response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
})
it('serves health immediately but gates readiness and API responses until warm-up completes', async () => {
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => true)
let response = await invoke(server, '/health')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({
status: 'ok',
ready: false,
})
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
response = await invoke(server, '/api/v1/mcpservers')
expect(response.statusCode).toBe(503)
server.setReady(true)
response = await invoke(server, '/api/v1/mcpservers')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toMatchObject({ servers: [], contextRef: '*' })
})
it('keeps the temporary global v1 inventory metadata-only and non-cacheable', async () => {
server = new ContextMapperServer(
new FakeProvider([
{
name: 'server-a',
description: 'must not be exposed by the legacy system inventory',
contextRef: 'context-a',
transport: {
type: 'streamableHttp',
url: 'http://server-a/mcp',
secretRef: 'nested-secret-must-not-leak',
} as McpServerInfo['transport'],
auth: { type: 'bearer', secretRef: 'server-a-auth', secretKey: 'token' },
enabled: true,
status: { deployed: true, ready: true, message: 'internal status detail' },
},
]),
0,
undefined,
undefined,
() => true
)
server.setReady(true)
const response = await invoke(server, '/api/v1/mcpservers')
expect(response.statusCode).toBe(200)
expect(response.headers['Cache-Control']).toBe('no-store, private')
expect(JSON.parse(response.body).servers[0]).not.toHaveProperty('auth')
expect(JSON.parse(response.body).servers[0]).not.toHaveProperty('description')
expect(response.body).not.toContain('secretRef')
expect(response.body).not.toContain('secretKey')
expect(response.body).not.toContain('nested-secret-must-not-leak')
expect(response.body).not.toContain('internal status detail')
})
it.each(['/api/v1/mcpservers/context/context-a', '/api/v1/mcpservers/server-a/auth'])(
'returns an application-level 410 tombstone for legacy route %s',
async path => {
server = new ContextMapperServer(new FakeProvider(), 0)
server.setReady(true)
const response = await invoke(server, path)
expect(response.statusCode).toBe(410)
expect(JSON.parse(response.body)).toEqual({ error: 'gone' })
expect(response.headers['Cache-Control']).toBe('no-store, private')
}
)
it('tombstones legacy Host-selected routes for every method before readiness and CORS', async () => {
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => true)
for (const [path, method] of [
['/api/v1/mcpservers/context/context-a', 'OPTIONS'],
['/api/v1/mcpservers/server-a/auth', 'POST'],
] as const) {
const response = await invoke(server, path, { method })
expect(response.statusCode).toBe(410)
expect(JSON.parse(response.body)).toEqual({ error: 'gone' })
expect(response.headers['Access-Control-Allow-Origin']).toBeUndefined()
expect(response.headers['Cache-Control']).toBe('no-store, private')
}
})
it('serves scoped v2 inventory without wildcard browser CORS or Secret values', async () => {
const protectedRoute = protectedServer()
server = protectedRoute.server
const response = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(response.statusCode).toBe(200)
expect(response.headers['Access-Control-Allow-Origin']).toBeUndefined()
expect(response.headers['Cache-Control']).toBe('no-store, private')
const body = JSON.parse(response.body)
expect(body.servers).toEqual([
expect.objectContaining({ name: 'server-a', authRequired: true }),
])
expect(response.body).not.toContain('context-a')
expect(response.body).not.toContain('server-a-auth')
expect(response.body).not.toContain('credential-value')
expect(protectedRoute.store.secretValueReads).toBe(0)
})
it('keeps direct protected-route startup and not-found errors generic and non-cacheable', async () => {
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => true)
let response = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ error: 'authorization_unavailable' })
expect(response.headers['Cache-Control']).toBe('no-store, private')
server.setReady(true)
response = await invoke(server, '/api/v2/hosts/self/mcpservers/unknown')
expect(response.statusCode).toBe(404)
expect(JSON.parse(response.body)).toEqual({ error: 'not_found' })
expect(response.headers['Cache-Control']).toBe('no-store, private')
})
it('accepts only the exact credential body and returns the fenced token DTO', async () => {
const protectedRoute = protectedServer()
server = protectedRoute.server
const response = await invoke(server, '/api/v2/hosts/self/mcpservers/credential', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ serverName: 'server-a' }),
})
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({
token: 'credential-value',
credentialRevision: expect.any(String),
})
expect(protectedRoute.store.secretValueReads).toBe(1)
const invalid = await invoke(server, '/api/v2/hosts/self/mcpservers/credential', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ serverName: 'server-a', contextRef: 'context-b' }),
})
expect(invalid.statusCode).toBe(400)
expect(protectedRoute.store.secretValueReads).toBe(1)
})
it.each([
['authorization_unavailable' as const, 503],
['credential_unavailable' as const, 503],
['not_found' as const, 404],
['unauthorized' as const, 401],
])('maps credential %s failures to a token-free fail-closed response', async (code, status) => {
const authenticator = { authenticate: () => principal } as unknown as McpApiAuthenticator
const authorization = {
getCredential: async () => {
throw new McpAuthorizationError(code)
},
} as unknown as McpAuthorizationService
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => true,
() => true,
authenticator,
authorization
)
server.setReady(true)
const response = await invoke(server, '/api/v2/hosts/self/mcpservers/credential', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ serverName: 'server-a' }),
})
expect(response.statusCode).toBe(status)
expect(JSON.parse(response.body)).toEqual({ error: code })
expect(response.body).not.toContain('token')
expect(response.headers['Cache-Control']).toBe('no-store, private')
})
it('normalizes protected route method, media-type, and body-limit failures without a Secret read', async () => {
const protectedRoute = protectedServer()
server = protectedRoute.server
let response = await invoke(server, '/api/v2/hosts/self/mcpservers', { method: 'POST' })
expect(response.statusCode).toBe(405)
expect(JSON.parse(response.body)).toEqual({ error: 'method_not_allowed' })
expect(response.headers.Allow).toBe('GET')
response = await invoke(server, '/api/v2/hosts/self/mcpservers/credential', {
method: 'POST',
headers: { 'content-type': 'text/plain' },
body: '{}',
})
expect(response.statusCode).toBe(415)
expect(JSON.parse(response.body)).toEqual({ error: 'unsupported_media_type' })
response = await invoke(server, '/api/v2/hosts/self/mcpservers/credential', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ serverName: 'a'.repeat(1_025) }),
})
expect(response.statusCode).toBe(413)
expect(JSON.parse(response.body)).toEqual({ error: 'payload_too_large' })
expect(response.headers['Cache-Control']).toBe('no-store, private')
expect(protectedRoute.store.secretValueReads).toBe(0)
})
it('fails closed when the protected Host verifier is not configured', async () => {
server = new ContextMapperServer(new FakeProvider(), 0)
server.setReady(true)
const response = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ error: 'authorization_unavailable' })
expect(response.headers['Cache-Control']).toBe('no-store, private')
})
it('maps a rebound Host identity to a generic non-cacheable 401', async () => {
const authenticator = { authenticate: () => principal } as unknown as McpApiAuthenticator
const authorization = {
listServers: async () => {
throw new McpAuthorizationError('unauthorized')
},
} as unknown as McpAuthorizationService
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => true,
() => true,
authenticator,
authorization
)
server.setReady(true)
const response = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(response.statusCode).toBe(401)
expect(JSON.parse(response.body)).toEqual({ error: 'unauthorized' })
expect(response.headers['WWW-Authenticate']).toBe('Bearer realm="host-context-controller"')
expect(response.headers['Cache-Control']).toBe('no-store, private')
expect(response.headers.Pragma).toBe('no-cache')
})
})
describe('McpHostApiRateLimiter', () => {
let server: ContextMapperServer | null = null
afterEach(async () => {
await server?.stop()
server = null
vi.restoreAllMocks()
})
it('limits each signed Host identity/action independently and resets after one minute', () => {
let now = 1_000
const limiter = new McpHostApiRateLimiter(1, () => now)
expect(limiter.consume('host-uid-a', 'credential')).toEqual({ allowed: true })
expect(limiter.consume('host-uid-a', 'inventory')).toEqual({ allowed: true })
expect(limiter.consume('host-uid-b', 'credential')).toEqual({ allowed: true })
expect(limiter.consume('host-uid-a', 'credential')).toEqual({
allowed: false,
retryAfterSeconds: 60,
})
now += 60_000
expect(limiter.consume('host-uid-a', 'credential')).toEqual({ allowed: true })
})
it('tracks provider authority dynamically after warm-up and fails API requests closed', async () => {
let providerAuthoritative = true
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => providerAuthoritative
)
let response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'starting', ready: false })
server.setReady(true)
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({ status: 'ready', ready: true })
providerAuthoritative = false
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'degraded', ready: false })
response = await invoke(server, '/health')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({
status: 'ok',
ready: false,
})
response = await invoke(server, '/api/v1/mcpservers')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({
error: 'Service Unavailable',
message: 'Context mapper provider inventory is not authoritative',
})
providerAuthoritative = true
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({ status: 'ready', ready: true })
response = await invoke(server, '/api/v1/mcpservers')
expect(response.statusCode).toBe(200)
})
it('fails readiness closed when the provider authority check throws', async () => {
const authorityError = new Error('authority unavailable')
const errorLog = vi.spyOn(console, 'error').mockImplementation(() => undefined)
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => {
throw authorityError
})
server.setReady(true)
const response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'degraded', ready: false })
const readinessErrors = errorLog.mock.calls
.map(args => {
try {
return JSON.parse(String(args[0])) as {
msg?: string
err?: { name?: string; message?: string }
}
} catch {
return null
}
})
.filter((entry): entry is { msg: string; err?: { name?: string; message?: string } } =>
Boolean(entry && entry.msg === 'provider authority readiness check failed')
)
expect(readinessErrors).toHaveLength(1)
expect(readinessErrors[0].err).toEqual({
name: authorityError.name,
message: authorityError.message,
})
})
it('withdraws readiness as soon as shutdown begins', async () => {
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => true)
server.setReady(true)
expect((await invoke(server, '/ready')).statusCode).toBe(200)
await server.stop()
const response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'starting', ready: false })
})
})
describe('ContextMapperServer desktop status authority', () => {
let server: ContextMapperServer | null = null
// A Host reconciler that reports a running desktop, so the only thing that can
// withhold a 200 is the Host-authority gate under test.
const runningReconciler = {
getStatus: () => ({ deployed: true, ready: true, message: '' }),
hasDesktop: () => true,
} as unknown as ConstructorParameters<typeof ContextMapperServer>[2]
const hasDesktopFn = () => true
afterEach(async () => {
await server?.stop()
server = null
vi.restoreAllMocks()
})
it('serves desktop status on Host authority alone even when the provider inventory is not authoritative', async () => {
// The heart of H1: desktop needs only Host authority. A degraded
// McpServer/Context lane (providerAuthoritative=false) must NOT 503 desktop,
// while /api/v1/mcpservers still 503s on the same server.
server = new ContextMapperServer(
new FakeProvider(),
0,
runningReconciler,
hasDesktopFn,
() => false, // provider inventory NOT authoritative
() => true // Host inventory authoritative
)
server.setReady(true)
const desktop = await invoke(server, '/api/v1/desktop/host-a')
expect(desktop.statusCode).toBe(200)
expect(JSON.parse(desktop.body)).toEqual({ status: 'running', hostRef: 'host-a' })
const mcpservers = await invoke(server, '/api/v1/mcpservers')
expect(mcpservers.statusCode).toBe(503)
})
it('fails desktop closed (503, never 200 inactive) when Host inventory is not authoritative', async () => {
server = new ContextMapperServer(
new FakeProvider(),
0,
runningReconciler,
hasDesktopFn,
() => true, // provider authoritative — must not rescue desktop
() => false // Host inventory NOT authoritative
)
server.setReady(true)
const desktop = await invoke(server, '/api/v1/desktop/host-a')
expect(desktop.statusCode).toBe(503)
expect(JSON.parse(desktop.body)).toEqual({
error: 'Service Unavailable',
message: 'Host inventory is not authoritative',
})
})
it('serves desktop status 200 in the dev wiring (no watcher), never 503 (R2-M1)', async () => {
// Wiring regression for R2-M1: main.ts resolves both authority gates from the
// same watcher. In dev (DevMcpServerProvider, watcher=null) the OLD wiring left
// the Host gate undefined, so the server's fail-closed default pinned every
// /api/v1/desktop/* at 503 after setReady(true) — where the base answered 200
// {status:'inactive'}. Exercise the REAL resolvers with a null watcher, exactly
// as main.ts does, so a revert to the undefined wiring turns this 200 into 503.
const providerAuthoritativeFn = resolveProviderAuthoritativeFn(null)
const hostAuthoritativeFn = resolveHostAuthoritativeFn(null)
server = new ContextMapperServer(
new FakeProvider(),
0,
runningReconciler,
hasDesktopFn,
providerAuthoritativeFn,
hostAuthoritativeFn
)
server.setReady(true)
const desktop = await invoke(server, '/api/v1/desktop/host-a')
expect(desktop.statusCode).toBe(200)
expect(JSON.parse(desktop.body)).toEqual({ status: 'running', hostRef: 'host-a' })
})
it('fails desktop closed when no Host-authority gate is wired (default)', async () => {
// Omitting the 6th arg must default to fail-closed, exactly like the
// provider gate — no type error catches the omission.
server = new ContextMapperServer(
new FakeProvider(),
0,
runningReconciler,
hasDesktopFn,
() => true
)
server.setReady(true)
const desktop = await invoke(server, '/api/v1/desktop/host-a')
expect(desktop.statusCode).toBe(503)
expect(JSON.parse(desktop.body)).toEqual({
error: 'Service Unavailable',
message: 'Host inventory is not authoritative',
})
})
it('fails desktop closed when the Host authority check throws', async () => {
const authorityError = new Error('host authority unavailable')
const errorLog = vi.spyOn(console, 'error').mockImplementation(() => undefined)
server = new ContextMapperServer(
new FakeProvider(),
0,
runningReconciler,
hasDesktopFn,
() => true,
() => {
throw authorityError
}
)
server.setReady(true)
const desktop = await invoke(server, '/api/v1/desktop/host-a')
expect(desktop.statusCode).toBe(503)
expect(JSON.parse(desktop.body)).toEqual({
error: 'Service Unavailable',
message: 'Host inventory is not authoritative',
})
const hostErrors = errorLog.mock.calls
.map(args => {
try {
return JSON.parse(String(args[0])) as {
msg?: string
err?: { name?: string; message?: string }
}
} catch {
return null
}
})
.filter((entry): entry is { msg: string; err?: { name?: string; message?: string } } =>
Boolean(entry && entry.msg === 'host authority check failed')
)
expect(hostErrors).toHaveLength(1)
expect(hostErrors[0].err).toEqual({
name: authorityError.name,
message: authorityError.message,
})
})
})
describe('ContextMapperServer /ready reasons', () => {
let server: ContextMapperServer | null = null
const authoritativeDetail = (): ReadinessInventoryDetail => ({
stopped: false,
mcpServerCacheSynced: true,
contextCacheSynced: true,
hostCacheSynced: true,
safetyInventoryCertified: true,
contextRevisionAligned: true,
serverRevisionAligned: true,
})
afterEach(async () => {
await server?.stop()
server = null
vi.restoreAllMocks()
})
it('adds closed-gate reasons on 503 and keeps the 200 body unchanged', async () => {
let detail = authoritativeDetail()
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() =>
!detail.stopped &&
detail.mcpServerCacheSynced &&
detail.contextCacheSynced &&
detail.hostCacheSynced &&
detail.safetyInventoryCertified &&
detail.contextRevisionAligned &&
detail.serverRevisionAligned,
() => false,
undefined,
undefined,
() => detail
)
server.setReady(true)
let response = await invoke(server, '/ready')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({ status: 'ready', ready: true })
expect(JSON.parse(response.body)).not.toHaveProperty('reasons')
detail = { ...detail, mcpServerCacheSynced: false, safetyInventoryCertified: false }
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['mcp_watch_unsynced', 'safety_pass_uncertified'],
})
})
it('omits reasons when the detail fn is missing or throws', async () => {
server = new ContextMapperServer(new FakeProvider(), 0, undefined, undefined, () => false)
server.setReady(true)
let response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'degraded', ready: false })
await server.stop()
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => false,
() => false,
undefined,
undefined,
() => {
throw new Error('detail unavailable')
}
)
server.setReady(true)
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({ status: 'degraded', ready: false })
expect(JSON.parse(response.body)).not.toHaveProperty('reasons')
})
it('names controller_stopped when stopped is the only closed clause', async () => {
const detail = { ...authoritativeDetail(), stopped: true }
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() =>
!detail.stopped &&
detail.mcpServerCacheSynced &&
detail.contextCacheSynced &&
detail.hostCacheSynced &&
detail.safetyInventoryCertified &&
detail.contextRevisionAligned &&
detail.serverRevisionAligned,
() => false,
undefined,
undefined,
() => detail
)
server.setReady(true)
const response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['controller_stopped'],
})
})
it('emits closed reasons through the omitted-probe fallback resolve*Fn wiring', async () => {
// A1 fallback / T10: the 10th constructor arg is omitted on purpose so
// /ready still uses the 6-clause provider gate. Production main.ts now
// wires resolveProbeAuthoritativeFn; that split is covered below.
let detail = authoritativeDetail()
const watcher = {
isReadinessInventoryAuthoritative: () =>
!detail.stopped &&
detail.mcpServerCacheSynced &&
detail.contextCacheSynced &&
detail.hostCacheSynced &&
detail.safetyInventoryCertified &&
detail.contextRevisionAligned &&
detail.serverRevisionAligned,
getReadinessInventoryDetail: () => detail,
}
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
resolveProviderAuthoritativeFn(watcher),
resolveHostAuthoritativeFn(null),
undefined,
undefined,
resolveReadinessDetailFn(watcher)
)
server.setReady(true)
let response = await invoke(server, '/ready')
expect(response.statusCode).toBe(200)
expect(JSON.parse(response.body)).toEqual({ status: 'ready', ready: true })
detail = { ...detail, safetyInventoryCertified: false }
response = await invoke(server, '/ready')
expect(response.statusCode).toBe(503)
expect(JSON.parse(response.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['safety_pass_uncertified'],
})
})
})
describe('ContextMapperServer /ready probe cut (A1)', () => {
let server: ContextMapperServer | null = null
const authoritativeDetail = (
overrides: Partial<ReadinessInventoryDetail> = {}
): ReadinessInventoryDetail => ({
stopped: false,
mcpServerCacheSynced: true,
contextCacheSynced: true,
hostCacheSynced: true,
safetyInventoryCertified: true,
contextRevisionAligned: true,
serverRevisionAligned: true,
...overrides,
})
function sixClauseAuthoritative(detail: ReadinessInventoryDetail): boolean {
return (
!detail.stopped &&
detail.mcpServerCacheSynced &&
detail.contextCacheSynced &&
detail.hostCacheSynced &&
detail.safetyInventoryCertified &&
detail.contextRevisionAligned &&
detail.serverRevisionAligned
)
}
function mainLikeServer(
detailRef: { current: ReadinessInventoryDetail },
extras: {
authenticator?: McpApiAuthenticator
authorization?: McpAuthorizationService
} = {}
): ContextMapperServer {
const watcher = {
isReadinessInventoryAuthoritative: () => sixClauseAuthoritative(detailRef.current),
isHostInventoryAuthoritative: () =>
!detailRef.current.stopped && detailRef.current.hostCacheSynced,
getReadinessInventoryDetail: () => detailRef.current,
}
return new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
resolveProviderAuthoritativeFn(watcher),
resolveHostAuthoritativeFn(watcher),
extras.authenticator,
extras.authorization,
resolveReadinessDetailFn(watcher),
resolveProbeAuthoritativeFn(watcher)
)
}
afterEach(async () => {
await server?.stop()
server = null
vi.restoreAllMocks()
})
it('A1-T05 keeps /ready 200 when only the safety pass is uncertified', async () => {
const detailRef = { current: authoritativeDetail({ safetyInventoryCertified: false }) }
const authenticator = { authenticate: () => principal } as unknown as McpApiAuthenticator
server = mainLikeServer(detailRef, {
authenticator,
authorization: new McpAuthorizationService(new FakeAuthorityStore()),
})
server.setReady(true)
const ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(200)
expect(JSON.parse(ready.body)).toEqual({ status: 'ready', ready: true })
expect(JSON.parse(ready.body)).not.toHaveProperty('reasons')
const inventory = await invoke(server, '/api/v1/mcpservers')
expect(inventory.statusCode).toBe(503)
const hostInventory = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(hostInventory.statusCode).toBe(503)
expect(JSON.parse(hostInventory.body)).toEqual({ error: 'authorization_unavailable' })
})
it.each([
['serverRevisionAligned', { serverRevisionAligned: false }],
['contextRevisionAligned', { contextRevisionAligned: false }],
] as const)('A1-T06 keeps /ready 200 when only %s is false', async (_name, override) => {
const detailRef = { current: authoritativeDetail(override) }
const authenticator = { authenticate: () => principal } as unknown as McpApiAuthenticator
server = mainLikeServer(detailRef, {
authenticator,
authorization: new McpAuthorizationService(new FakeAuthorityStore()),
})
server.setReady(true)
const ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(200)
expect(JSON.parse(ready.body)).toEqual({ status: 'ready', ready: true })
expect(JSON.parse(ready.body)).not.toHaveProperty('reasons')
const inventory = await invoke(server, '/api/v1/mcpservers')
expect(inventory.statusCode).toBe(503)
const hostInventory = await invoke(server, '/api/v2/hosts/self/mcpservers')
expect(hostInventory.statusCode).toBe(503)
expect(JSON.parse(hostInventory.body)).toEqual({ error: 'authorization_unavailable' })
})
it('A1-T07 reports only the host watch reason on /ready when phase-2 is also down', async () => {
const detailRef = {
current: authoritativeDetail({
hostCacheSynced: false,
safetyInventoryCertified: false,
}),
}
server = mainLikeServer(detailRef)
server.setReady(true)
const ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['host_watch_unsynced'],
})
})
it('A1-T08 withholds /ready while starting or stopping even if the probe gate is always true', async () => {
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => true,
() => true,
undefined,
undefined,
undefined,
() => true
)
let ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({ status: 'starting', ready: false })
server.setReady(true)
ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(200)
server.setReady(false)
ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({ status: 'starting', ready: false })
server.setReady(true)
await server.stop()
ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({ status: 'starting', ready: false })
})
it('A1-T09 fails /ready closed when the probe gate throws', async () => {
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => true,
() => true,
undefined,
undefined,
undefined,
() => {
throw new Error('probe authority unavailable')
}
)
server.setReady(true)
const ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({ status: 'degraded', ready: false })
})
it('A1-T10 keeps /ready on the 6-clause gate when the 10th argument is omitted', async () => {
const detail = authoritativeDetail({ safetyInventoryCertified: false })
server = new ContextMapperServer(
new FakeProvider(),
0,
undefined,
undefined,
() => sixClauseAuthoritative(detail),
() => false,
undefined,
undefined,
() => detail
)
server.setReady(true)
const ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['safety_pass_uncertified'],
})
})
it('A1-T11 503s both lanes when the MCP watch is unsynced and heals both on the same instance', async () => {
const detailRef = { current: authoritativeDetail({ mcpServerCacheSynced: false }) }
server = mainLikeServer(detailRef)
server.setReady(true)
let ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(503)
expect(JSON.parse(ready.body)).toEqual({
status: 'degraded',
ready: false,
reasons: ['mcp_watch_unsynced'],
})
let inventory = await invoke(server, '/api/v1/mcpservers')
expect(inventory.statusCode).toBe(503)
detailRef.current = authoritativeDetail()
ready = await invoke(server, '/ready')
expect(ready.statusCode).toBe(200)
expect(JSON.parse(ready.body)).toEqual({ status: 'ready', ready: true })
inventory = await invoke(server, '/api/v1/mcpservers')
expect(inventory.statusCode).toBe(200)
})
it('A1-T15 logs distinct lanes when the probe is ready and the data path is not', async () => {
const infoSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
try {
const detailRef = {
current: authoritativeDetail({
safetyInventoryCertified: false,
contextRevisionAligned: false,
serverRevisionAligned: false,
}),
}
server = mainLikeServer(detailRef)
server.setReady(true)
expect((await invoke(server, '/ready')).statusCode).toBe(200)
expect((await invoke(server, '/health')).statusCode).toBe(200)
expect(JSON.parse((await invoke(server, '/health')).body).ready).toBe(false)
const infoLines = infoSpy.mock.calls.map(call => String(call[0]))
const warnLines = warnSpy.mock.calls.map(call => String(call[0]))
expect(infoLines.some(line => line.includes('"lane":"probe"'))).toBe(true)
expect(warnLines.some(line => line.includes('"lane":"request"'))).toBe(true)
} finally {
infoSpy.mockRestore()
warnSpy.mockRestore()
}
})
it('A1-T16 describes /ready as watch-freshness on GET /', async () => {
server = mainLikeServer({ current: authoritativeDetail() })
const response = await invoke(server, '/')
expect(response.statusCode).toBe(200)
const body = JSON.parse(response.body) as { endpoints: Record<string, string> }
expect(body.endpoints['GET /ready']).toContain('watch inventory is fresh')
expect(body.endpoints['GET /ready']).not.toContain('provider inventory is authoritative')
})
it('A1-T17 keeps /health.ready on the 6-clause gate while /ready is 200', async () => {
const detailRef = {
current: authoritativeDetail({ safetyInventoryCertified: false }),
}
server = mainLikeServer(detailRef)
server.setReady(true)
const ready = await invoke(server, '/ready')
const health = await invoke(server, '/health')
expect(ready.statusCode).toBe(200)
expect(JSON.parse(ready.body)).toEqual({ status: 'ready', ready: true })
expect(health.statusCode).toBe(200)
expect(JSON.parse(health.body)).toEqual({ status: 'ok', ready: false })
})
})