Skip to content

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

TypeScript

Merge branch 'feat/mcp-server-oauth-host' into feat/mcp-server-oauth-desktop

Diego Zacariasa93aef8a9acd
diff --cc desktop-app/src/main.ts
index 328826aff,4475fe156..bad38941c
--- a/desktop-app/src/main.ts
+++ b/desktop-app/src/main.ts
@@@ -1,8 -1,8 +1,9 @@@
import { BrowserWindow, app, ipcMain, nativeTheme, powerMonitor } from 'electron'
import path from 'node:path'
import { AppService } from './appService.js'
+import { routeClerumOauthCompleted } from './clerumDeepLink.js'
import { config } from './config.js'
+ import { installDesktopTextContextMenus } from './desktopTextContextMenu.js'
import { createEvenfireDeepLinkRouter } from './evenfireDeepLinkRouter.js'
import { assertTrustedSender, registerIpcHandlers } from './ipc.js'
import { createMainWindowCoordinator, createRetryableInitializer } from './mainWindowCoordinator.js'
diff --cc external-rest-api/src/releaseManifest.ts
index 6fac0b56d,127cbd36a..37e2bd371
--- a/external-rest-api/src/releaseManifest.ts
+++ b/external-rest-api/src/releaseManifest.ts
@@@ -8,8 -8,8 +8,8 @@@ export type ReleaseManifest =
export const releaseManifest: ReleaseManifest = {
releaseId: 'v0.7.0',
- externalRestApiVersion: '0.1.80',
+ externalRestApiVersion: '0.1.81',
- rpcProxyVersion: '0.1.65',
+ rpcProxyVersion: '0.1.66',
desktopVersion: '0.7.0',
minimumDesktopVersion: '0.1.252',
}
diff --cc host-context-controller/src/mcpAuthorization.test.ts
index 000000000,2af2cc9c1..98471acba
mode 000000,100644..100644
--- a/host-context-controller/src/mcpAuthorization.test.ts
+++ b/host-context-controller/src/mcpAuthorization.test.ts
@@@ -1,0 -1,632 +1,651 @@@
+ import { describe, expect, it, vi } from 'vitest'
+ import type { VerifiedMcpHostPrincipal } from './mcpApiAuthentication'
+ import {
+ type AuthorityContext,
+ type AuthorityHost,
+ type AuthorityMcpServer,
+ type AuthoritySecret,
+ type AuthoritySecretMetadata,
- deriveAuthKind,
+ McpAuthorizationService,
+ type McpAuthorizationStore,
++ deriveAuthKind,
+ toPublicMcpTransport,
+ } from './mcpAuthorization'
+ import type { McpServerOAuth } from './types'
+
+ // A complete McpServerOAuth block, shaped like the CRD `spec.oauth` the real
+ // producer (k8sClient.readMcpServer) projects — never a hand-built partial.
+ const fullOAuth = (grantScope: 'user' | 'context'): McpServerOAuth => ({
+ id: 'oauth-adapter',
+ provider: 'google',
+ clientIdRef: { name: 'oauth-secret', key: 'client-id' },
+ clientSecretRef: { name: 'oauth-secret', key: 'client-secret' },
+ grantScope,
+ })
+
+ const meta = (uid: string, resourceVersion: string) => ({ uid, resourceVersion })
+ 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'],
+ }
+ const principalB: VerifiedMcpHostPrincipal = {
+ ...principal,
+ hostName: 'host-b',
+ hostUid: 'host-uid-b',
+ jti: 'jti-b',
+ }
+ const host: AuthorityHost = {
+ name: 'host-a',
+ namespace: 'mcp-host',
+ metadata: meta('host-uid-a', '10'),
+ contextRef: 'context-a',
+ }
+ const context: AuthorityContext = {
+ name: 'context-a',
+ namespace: 'mcp-server',
+ metadata: meta('context-uid-a', '20'),
+ mcpServers: ['server-a'],
+ }
+ const contextB: AuthorityContext = {
+ name: 'context-b',
+ namespace: 'mcp-server',
+ metadata: meta('context-uid-b', '21'),
+ mcpServers: ['server-b'],
+ }
+ const server: AuthorityMcpServer = {
+ name: 'server-a',
+ namespace: 'mcp-server',
+ metadata: meta('server-uid-a', '30'),
+ transport: { type: 'streamableHttp', url: 'http://server-a/mcp' },
+ auth: { type: 'bearer', secretRef: 'server-a-auth', secretKey: 'token' },
+ enabled: true,
+ status: { deployed: true, ready: true, authoritative: false },
+ }
+ const serverB: AuthorityMcpServer = {
+ ...server,
+ name: 'server-b',
+ metadata: meta('server-uid-b', '31'),
+ transport: { type: 'streamableHttp', url: 'http://server-b/mcp' },
+ auth: { type: 'bearer', secretRef: 'server-b-auth', secretKey: 'token' },
+ }
+ const secret: AuthoritySecret = {
+ name: 'server-a-auth',
+ namespace: 'mcp-server',
+ metadata: meta('secret-uid-a', '40'),
+ data: { token: Buffer.from('credential-value').toString('base64') },
+ }
+
+ class FakeStore implements McpAuthorizationStore {
+ secretMetadataReads = 0
+ secretValueReads = 0
+ secretMetadataSequence: Array<AuthoritySecretMetadata | null> = [secret]
+ secretSequence: Array<AuthoritySecret | null> = [secret]
+ hostSequence: Array<AuthorityHost | null> | null = null
+ contextSequence: Array<AuthorityContext | null> | null = null
+ serverSequence: Array<AuthorityMcpServer | null> | null = null
+ hostObjects: Map<string, AuthorityHost | null> | null = null
+ contextObjects: Map<string, AuthorityContext | null> | null = null
+ serverObjects: Map<string, AuthorityMcpServer | null> | null = null
+ secretMetadataObjects: Map<string, AuthoritySecretMetadata | null> | null = null
+ secretObjects: Map<string, AuthoritySecret | null> | null = null
+ hostReads = 0
+ contextReads = 0
+ serverReads = 0
+ hostObject: AuthorityHost | null = host
+ contextObject: AuthorityContext | null = context
+ serverObject: AuthorityMcpServer | null = server
+
+ async readHost(name: string) {
+ this.hostReads += 1
+ if (this.hostObjects) return this.hostObjects.get(name) ?? null
+ return this.hostSequence
+ ? this.hostSequence[Math.min(this.hostReads - 1, this.hostSequence.length - 1)]
+ : this.hostObject
+ }
+ async readContext(name: string) {
+ this.contextReads += 1
+ if (this.contextObjects) return this.contextObjects.get(name) ?? null
+ return this.contextSequence
+ ? this.contextSequence[Math.min(this.contextReads - 1, this.contextSequence.length - 1)]
+ : this.contextObject
+ }
+ async readMcpServer(name: string) {
+ this.serverReads += 1
+ if (this.serverObjects) return this.serverObjects.get(name) ?? null
+ return this.serverSequence
+ ? this.serverSequence[Math.min(this.serverReads - 1, this.serverSequence.length - 1)]
+ : this.serverObject
+ }
+ async readSecretMetadata(name: string) {
+ this.secretMetadataReads += 1
+ if (this.secretMetadataObjects) return this.secretMetadataObjects.get(name) ?? null
+ const value =
+ this.secretMetadataSequence[
+ Math.min(this.secretMetadataReads - 1, this.secretMetadataSequence.length - 1)
+ ]
+ return value ? { name: value.name, namespace: value.namespace, metadata: value.metadata } : null
+ }
+ async readSecret(name: string) {
+ this.secretValueReads += 1
+ if (this.secretObjects) return this.secretObjects.get(name) ?? null
+ return this.secretSequence[Math.min(this.secretValueReads - 1, this.secretSequence.length - 1)]
+ }
+ }
+
+ async function expectCredentialFailure(
+ service: McpAuthorizationService,
+ code: string
+ ): Promise<void> {
+ const error = await service.getCredential(principal, 'server-a').then(
+ () => null,
+ reason => reason
+ )
+ expect(error).toMatchObject({ code })
+ expect(error).not.toHaveProperty('token')
+ expect(JSON.stringify(error)).not.toContain(
+ Buffer.from(secret.data.token, 'base64').toString('utf8')
+ )
+ }
+
+ describe('McpAuthorizationService', () => {
+ it('keeps two Host/Context grant sets disjoint in both directions', async () => {
+ const hostB: AuthorityHost = {
+ name: 'host-b',
+ namespace: 'mcp-host',
+ metadata: meta('host-uid-b', '11'),
+ contextRef: 'context-b',
+ }
+ const secretB: AuthoritySecret = {
+ name: 'server-b-auth',
+ namespace: 'mcp-server',
+ metadata: meta('secret-uid-b', '41'),
+ data: { token: Buffer.from('credential-b').toString('base64') },
+ }
+ const store = new FakeStore()
+ store.hostObjects = new Map([
+ [host.name, host],
+ [hostB.name, hostB],
+ ])
+ store.contextObjects = new Map([
+ [context.name, context],
+ [contextB.name, contextB],
+ ])
+ store.serverObjects = new Map([
+ [server.name, server],
+ [serverB.name, serverB],
+ ])
+ store.secretMetadataObjects = new Map([
+ [secret.name, secret],
+ [secretB.name, secretB],
+ ])
+ store.secretObjects = new Map([
+ [secret.name, secret],
+ [secretB.name, secretB],
+ ])
+
+ const service = new McpAuthorizationService(store)
+ await expect(service.listServers(principal)).resolves.toEqual([
+ expect.objectContaining({ name: 'server-a' }),
+ ])
+ await expect(service.listServers(principalB)).resolves.toEqual([
+ expect.objectContaining({ name: 'server-b' }),
+ ])
+ const readsBeforeForeignRequests = {
+ secretMetadata: store.secretMetadataReads,
+ secretValue: store.secretValueReads,
+ }
+ await expect(service.getCredential(principal, 'server-b')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ await expect(service.getCredential(principalB, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(readsBeforeForeignRequests.secretMetadata)
+ expect(store.secretValueReads).toBe(readsBeforeForeignRequests.secretValue)
+ await expect(service.getCredential(principalB, 'server-b')).resolves.toMatchObject({
+ token: 'credential-b',
+ })
+ })
+
+ it('projects only valid TCP ports into the public transport contract', () => {
+ expect(toPublicMcpTransport({ type: 'streamableHttp', port: 65_535 })).toEqual({
+ type: 'streamableHttp',
+ port: 65_535,
+ })
+ for (const port of [0, -1, 65_536, 1.5]) {
+ expect(toPublicMcpTransport({ type: 'streamableHttp', port })).toEqual({
+ type: 'streamableHttp',
+ })
+ }
+ })
+
+ it('returns only the current Context inventory and an opaque Secret-aware revision', async () => {
+ const store = new FakeStore()
+ const service = new McpAuthorizationService(store)
+ const inventory = await service.listServers(principal)
+ expect(inventory).toEqual([
+ expect.objectContaining({
+ name: 'server-a',
+ authRequired: true,
+ credentialRevision: expect.any(String),
+ status: { deployed: true, ready: true, authoritative: false },
+ }),
+ ])
+ expect(inventory[0]).not.toHaveProperty('contextRef')
+ expect(inventory[0]).not.toHaveProperty('auth')
+ expect(JSON.stringify(inventory)).not.toContain('credential-value')
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('authorizes before Secret read and returns the same revision for a stable credential', async () => {
+ const store = new FakeStore()
+ const service = new McpAuthorizationService(store)
+ const inventory = await service.listServers(principal)
+ const credential = await service.getCredential(principal, 'server-a')
+ expect(credential).toEqual({
+ token: 'credential-value',
+ credentialRevision: inventory[0].credentialRevision,
+ })
+ })
+
+ it('performs zero Secret reads for a cross-Context or unknown target', async () => {
+ const store = new FakeStore()
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-b')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it.each(['host', 'context', 'server', 'secret-metadata', 'secret-value'] as const)(
+ 'fails closed without disclosing a credential when the %s store read errors',
+ async read => {
+ const store = new FakeStore()
+ if (read === 'host')
+ vi.spyOn(store, 'readHost').mockRejectedValueOnce(new Error('read failed'))
+ if (read === 'context') {
+ vi.spyOn(store, 'readContext').mockRejectedValueOnce(new Error('read failed'))
+ }
+ if (read === 'server') {
+ vi.spyOn(store, 'readMcpServer').mockRejectedValueOnce(new Error('read failed'))
+ }
+ if (read === 'secret-metadata') {
+ vi.spyOn(store, 'readSecretMetadata').mockRejectedValueOnce(new Error('read failed'))
+ }
+ if (read === 'secret-value') {
+ vi.spyOn(store, 'readSecret').mockRejectedValueOnce(new Error('read failed'))
+ }
+ const service = new McpAuthorizationService(store)
+
+ await expectCredentialFailure(service, 'authorization_unavailable')
+ if (read !== 'secret-value') expect(store.secretValueReads).toBe(0)
+ if (read === 'host' || read === 'context' || read === 'server') {
+ expect(store.secretMetadataReads).toBe(0)
+ }
+ }
+ )
+
+ it.each([
+ ['missing secretRef', { auth: { type: 'bearer' as const } }, secret],
+ ['missing Secret metadata', {}, null],
+ ])('rejects %s before any Secret value read', async (_label, serverOverride, metadataValue) => {
+ const store = new FakeStore()
+ store.serverObject = { ...server, ...(serverOverride as Partial<AuthorityMcpServer>) }
+ store.secretMetadataSequence = metadataValue
+ ? [metadataValue as AuthoritySecretMetadata]
+ : [null]
+ const service = new McpAuthorizationService(store)
+
+ await expectCredentialFailure(service, 'credential_unavailable')
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it.each([
+ ['missing configured key', { other: Buffer.from('other').toString('base64') }],
+ ['empty base64', { token: '' }],
+ ['malformed base64', { token: 'invalid-test-token' }],
+ ['non-UTF8 base64', { token: Buffer.from([0xff]).toString('base64') }],
+ ])('rejects %s without returning Secret data', async (_label, data) => {
+ const store = new FakeStore()
+ store.secretSequence = [{ ...secret, data }]
+ const service = new McpAuthorizationService(store)
+
+ await expectCredentialFailure(service, 'credential_unavailable')
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('uses the same opaque denial for a cross-Context and an unknown target', async () => {
+ const store = new FakeStore()
+ const service = new McpAuthorizationService(store)
+ const denied = await Promise.allSettled([
+ service.getCredential(principal, 'server-b'),
+ service.getCredential(principal, 'unknown-server'),
+ ])
+ expect(
+ denied.map(result => (result.status === 'rejected' ? result.reason.code : null))
+ ).toEqual(['not_found', 'not_found'])
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('does not read Secret metadata or values for a disabled or deleting server', async () => {
+ const store = new FakeStore()
+ store.serverObject = { ...server, enabled: false }
+ const service = new McpAuthorizationService(store)
+ await expect(service.listServers(principal)).resolves.toEqual([])
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+
+ store.serverObject = { ...server, metadata: { ...server.metadata, deletionTimestamp: 'now' } }
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('returns a null token without reading a Secret when the server has no auth', async () => {
+ const store = new FakeStore()
+ store.serverObject = { ...server, auth: { type: 'none' } }
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-a')).resolves.toEqual({
+ token: null,
+ credentialRevision: expect.any(String),
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('changes the credential revision when the McpServer secretKey changes', async () => {
+ const store = new FakeStore()
+ store.serverObject = { ...server, auth: { ...server.auth!, secretKey: 'rotated' } }
+ store.secretSequence = [
+ {
+ ...secret,
+ data: {
+ token: Buffer.from('old').toString('base64'),
+ rotated: Buffer.from('new').toString('base64'),
+ },
+ },
+ ]
+ store.secretMetadataSequence = [store.secretSequence[0]]
+ const service = new McpAuthorizationService(store)
+ const first = await service.getCredential(principal, 'server-a')
+ store.serverObject = { ...server, auth: { ...server.auth!, secretKey: 'token' } }
+ store.secretMetadataReads = 0
+ store.secretValueReads = 0
+ const second = await service.getCredential(principal, 'server-a')
+ expect(first.credentialRevision).not.toBe(second.credentialRevision)
+ expect(first.token).toBe('new')
+ expect(second.token).toBe('old')
+ })
+
+ it('enumerates no foreign server and performs zero Secret reads outside the Context grant', async () => {
+ const store = new FakeStore()
+ store.contextObject = { ...context, mcpServers: [] }
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.listServers(principal)).resolves.toEqual([])
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('performs zero Secret reads when an old JWT is rebound to a recreated Host name', async () => {
+ const store = new FakeStore()
+ store.hostObject = { ...host, metadata: meta('replacement-uid', '11') }
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'unauthorized',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it.each([
+ ['missing', null],
+ ['deleting', { ...host, metadata: { ...host.metadata, deletionTimestamp: 'now' } }],
+ ])('performs zero Secret reads when the authenticated Host is %s', async (_state, value) => {
+ const store = new FakeStore()
+ store.hostObject = value
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'unauthorized',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it.each([
+ ['missing', null],
+ ['deleting', { ...context, metadata: { ...context.metadata, deletionTimestamp: 'now' } }],
+ ])('performs zero Secret reads when the live Context is %s', async (_state, value) => {
+ const store = new FakeStore()
+ store.contextObject = value
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('discards inventory when the Host binding changes before the response', async () => {
+ const store = new FakeStore()
+ store.hostSequence = [host, { ...host, metadata: meta('host-uid-a', '11') }]
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.listServers(principal)).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('discards inventory when the Context allowlist changes before the response', async () => {
+ const store = new FakeStore()
+ store.contextSequence = [
+ context,
+ { ...context, metadata: meta('context-uid-a', '21'), mcpServers: [] },
+ ]
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.listServers(principal)).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(0)
+ })
+
+ it('discards a credential when the Secret changes during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.secretMetadataSequence = [secret, { ...secret, metadata: meta('secret-uid-a', '41') }]
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(2)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('rejects a credential when the Host is rebound during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.hostSequence = [host, { ...host, metadata: meta('replacement-host-uid', '1') }]
+ const service = new McpAuthorizationService(store)
+
+ await expectCredentialFailure(service, 'unauthorized')
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('rejects a credential when the Context allowlist changes during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.contextSequence = [context, { ...context, mcpServers: [] }]
+ const service = new McpAuthorizationService(store)
+
+ await expectCredentialFailure(service, 'not_found')
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('discards a credential when the McpServer changes during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.serverSequence = [server, { ...server, metadata: meta('server-uid-a', '31') }]
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(2)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('fails closed when the McpServer disappears during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.serverSequence = [server, null]
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('discards a credential when the McpServer is recreated under the same name', async () => {
+ const store = new FakeStore()
+ store.serverSequence = [server, { ...server, metadata: meta('replacement-server-uid', '1') }]
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(2)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('fails closed when the Secret disappears during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.secretMetadataSequence = [secret, null]
+ const service = new McpAuthorizationService(store)
+
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'authorization_unavailable',
+ })
+ expect(store.secretMetadataReads).toBe(2)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('fails closed when the Context disappears during the post-read fence', async () => {
+ const store = new FakeStore()
+ store.contextSequence = [context, null]
+ const service = new McpAuthorizationService(store)
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'not_found',
+ })
+ expect(store.secretMetadataReads).toBe(1)
+ expect(store.secretValueReads).toBe(1)
+ })
+
+ it('rejects an expired principal before any Kubernetes authority read', async () => {
+ const store = new FakeStore()
+ const service = new McpAuthorizationService(store, () => principal.expiresAt)
+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({
+ code: 'unauthorized',
+ })
+ expect(store.secretMetadataReads).toBe(0)
+ expect(store.secretValueReads).toBe(0)
+ })
+ })
+
+ describe('deriveAuthKind (mini-spec 10 §3.1)', () => {
+ it.each([
- ['oauth + grantScope=user → oauth-user', { type: 'oauth' as const }, { grantScope: 'user' as const }, true, 'oauth-user'],
- ['oauth + grantScope=context → oauth-context', { type: 'oauth' as const }, { grantScope: 'context' as const }, true, 'oauth-context'],
- ['oauth + grantScope absent → oauth-user (CEL default)', { type: 'oauth' as const }, undefined, true, 'oauth-user'],
++ [
++ 'oauth + grantScope=user → oauth-user',
++ { type: 'oauth' as const },
++ { grantScope: 'user' as const },
++ true,
++ 'oauth-user',
++ ],
++ [
++ 'oauth + grantScope=context → oauth-context',
++ { type: 'oauth' as const },
++ { grantScope: 'context' as const },
++ true,
++ 'oauth-context',
++ ],
++ [
++ 'oauth + grantScope absent → oauth-user (CEL default)',
++ { type: 'oauth' as const },
++ undefined,
++ true,
++ 'oauth-user',
++ ],
+ ['bearer (authRequired) → static', { type: 'bearer' as const }, undefined, true, 'static'],
+ ['apiKey (authRequired) → static', { type: 'apiKey' as const }, undefined, true, 'static'],
+ ['none → undefined (omitted)', { type: 'none' as const }, undefined, false, undefined],
+ ['absent auth → undefined', undefined, undefined, false, undefined],
+ ])('%s', (_label, auth, oauth, authRequired, expected) => {
+ expect(deriveAuthKind(auth as never, oauth as never, authRequired)).toBe(expected)
+ })
+
+ it('never collapses an oauth server to static across every grantScope', () => {
+ for (const grantScope of ['user', 'context', undefined] as const) {
- const kind = deriveAuthKind(
- { type: 'oauth' },
- grantScope ? { grantScope } : undefined,
- true
- )
++ const kind = deriveAuthKind({ type: 'oauth' }, grantScope ? { grantScope } : undefined, true)
+ expect(kind).not.toBe('static')
+ expect(kind?.startsWith('oauth-')).toBe(true)
+ }
+ })
+
+ it('is idempotent: same inputs yield the same authKind', () => {
+ const a = deriveAuthKind({ type: 'oauth' }, { grantScope: 'context' }, true)
+ const b = deriveAuthKind({ type: 'oauth' }, { grantScope: 'context' }, true)
+ expect(a).toBe(b)
+ })
+ })
+
+ describe('listServers authKind emission (mini-spec 10 §3.2, T1)', () => {
+ it.each([
+ ['oauth-user', { type: 'oauth' as const }, fullOAuth('user'), 'oauth-user'],
+ ['oauth-context', { type: 'oauth' as const }, fullOAuth('context'), 'oauth-context'],
- ['static (bearer)', { type: 'bearer' as const, secretRef: 'server-a-auth', secretKey: 'token' }, undefined, 'static'],
++ [
++ 'static (bearer)',
++ { type: 'bearer' as const, secretRef: 'server-a-auth', secretKey: 'token' },
++ undefined,
++ 'static',
++ ],
+ ])('emits authKind=%s derived from the real producer', async (_label, auth, oauth, expected) => {
+ const store = new FakeStore()
+ store.serverObject = {
+ ...server,
+ auth,
+ ...(oauth ? { oauth } : {}),
+ }
+ const service = new McpAuthorizationService(store)
+ const inventory = await service.listServers(principal)
+ expect(inventory[0].authKind).toBe(expected)
+ // I1: the wire projection never leaks context/auth identity.
+ expect(inventory[0]).not.toHaveProperty('contextRef')
+ expect(inventory[0]).not.toHaveProperty('auth')
+ expect(inventory[0]).not.toHaveProperty('oauth')
+ })
+
+ it('omits authKind entirely for a no-auth server', async () => {
+ const store = new FakeStore()
+ store.serverObject = { ...server, auth: { type: 'none' } }
+ const service = new McpAuthorizationService(store)
+ const inventory = await service.listServers(principal)
+ expect(inventory[0]).not.toHaveProperty('authKind')
+ })
+ })
diff --cc host-context-controller/src/mcpAuthorization.ts
index 000000000,79378bacb..c314a90da
mode 000000,100644..100644
--- a/host-context-controller/src/mcpAuthorization.ts
+++ b/host-context-controller/src/mcpAuthorization.ts
@@@ -1,0 -1,409 +1,404 @@@
+ import { createHash } from 'node:crypto'
+ import type { VerifiedMcpHostPrincipal } from './mcpApiAuthentication'
-import type {
- McpServerAuth,
- McpServerOAuth,
- McpServerStatus,
- McpServerTransport,
-} from './types'
++import type { McpServerAuth, McpServerOAuth, McpServerStatus, McpServerTransport } from './types'
+
+ export interface AuthorityMetadata {
+ uid: string
+ resourceVersion: string
+ deletionTimestamp?: string
+ }
+
+ export interface AuthorityHost {
+ name: string
+ namespace: string
+ metadata: AuthorityMetadata
+ contextRef: string
+ }
+
+ export interface AuthorityContext {
+ name: string
+ namespace: string
+ metadata: AuthorityMetadata
+ mcpServers: readonly string[]
+ }
+
+ export interface AuthorityMcpServer {
+ name: string
+ namespace: string
+ metadata: AuthorityMetadata
+ description?: string
+ transport: McpServerTransport
+ auth?: McpServerAuth
+ // OAuth broker config (grantScope) from the CRD. Non-secret; used only to
+ // derive the inventory `authKind`. HCC never forwards it to mcp-host raw.
+ oauth?: McpServerOAuth
+ enabled: boolean
+ status: McpServerStatus
+ }
+
+ export interface AuthoritySecretMetadata {
+ name: string
+ namespace: string
+ metadata: AuthorityMetadata
+ }
+
+ export interface AuthoritySecret extends AuthoritySecretMetadata {
+ data: Readonly<Record<string, string>>
+ }
+
+ export interface McpAuthorizationStore {
+ readHost(name: string): Promise<AuthorityHost | null>
+ readContext(name: string): Promise<AuthorityContext | null>
+ readMcpServer(name: string): Promise<AuthorityMcpServer | null>
+ readSecretMetadata(name: string): Promise<AuthoritySecretMetadata | null>
+ readSecret(name: string): Promise<AuthoritySecret | null>
+ }
+
+ export interface AuthorizedMcpServerInfo {
+ name: string
+ description?: string
+ transport: McpServerTransport
+ enabled: boolean
+ status: Pick<McpServerStatus, 'deployed' | 'ready'> &
+ Partial<Pick<McpServerStatus, 'authoritative'>>
+ authRequired: boolean
+ credentialRevision?: string
+ /**
+ * Non-secret credential-mode policy the mcp-host seam dispatches on
+ * (mini-spec 10 §3.2). Derived from the CRD auth selector; carries NO
+ * authority (no contextRef/secretRef/token). `none` is represented as an
+ * omitted field. Absent → mcp-host degrades to `static` (fail-closed).
+ */
+ authKind?: AuthorizedMcpAuthKind
+ }
+
+ export type AuthorizedMcpAuthKind = 'static' | 'oauth-user' | 'oauth-context'
+
+ /**
+ * Derive the non-secret `authKind` policy for the inventory (mini-spec 10 §3.1).
+ * Pure: same inputs → same output; an oauth server never collapses to `static`.
+ * Returns undefined for the implicit `none` (no auth required) so the caller
+ * omits the field.
+ */
+ export function deriveAuthKind(
+ auth: McpServerAuth | undefined,
+ // Only grantScope is read here; accepting the narrow shape documents the
+ // contract and lets callers pass a full McpServerOAuth (structurally wider).
+ oauth: Pick<McpServerOAuth, 'grantScope'> | undefined,
+ authRequired: boolean
+ ): AuthorizedMcpAuthKind | undefined {
+ if (auth?.type === 'oauth') {
+ return oauth?.grantScope === 'context' ? 'oauth-context' : 'oauth-user'
+ }
+ return authRequired ? 'static' : undefined
+ }
+
+ export interface AuthorizedCredential {
+ token: string | null
+ credentialRevision: string
+ }
+
+ /** Project only the transport keys that are part of the mcp-host wire contract. */
+ export function toPublicMcpTransport(transport: McpServerTransport): McpServerTransport {
+ return {
+ type: transport.type,
+ ...(typeof transport.url === 'string' ? { url: transport.url } : {}),
+ ...(Number.isSafeInteger(transport.port) &&
+ (transport.port ?? 0) > 0 &&
+ (transport.port ?? 0) <= 65_535
+ ? { port: transport.port }
+ : {}),
+ }
+ }
+
+ export type McpAuthorizationFailureCode =
+ | 'unauthorized'
+ | 'not_found'
+ | 'authorization_unavailable'
+ | 'credential_unavailable'
+
+ export class McpAuthorizationError extends Error {
+ constructor(readonly code: McpAuthorizationFailureCode) {
+ super(code)
+ this.name = 'McpAuthorizationError'
+ }
+ }
+
+ type AuthorizedHostContext = {
+ principal: VerifiedMcpHostPrincipal
+ host: AuthorityHost
+ context: AuthorityContext
+ }
+
+ type AuthorizedMcpServerGrant = AuthorizedHostContext & {
+ server: AuthorityMcpServer
+ secretMetadata: AuthoritySecretMetadata | null
+ credentialRevision: string
+ }
+
+ const FALLBACK_SECRET_KEYS = ['token', 'api-key', 'apiKey', 'password'] as const
+
+ function isLive(metadata: AuthorityMetadata): boolean {
+ return Boolean(metadata.uid && metadata.resourceVersion && !metadata.deletionTimestamp)
+ }
+
+ function selectSecretKey(secret: AuthoritySecret | null, configured?: string): string | null {
+ if (!secret) return null
+ const keys = configured ? [configured] : FALLBACK_SECRET_KEYS
+ return (
+ keys.find(key => Object.hasOwn(secret.data, key) && typeof secret.data[key] === 'string') ??
+ null
+ )
+ }
+
+ function decodeBase64Credential(value: unknown): string | null {
+ if (
+ typeof value !== 'string' ||
+ value.length === 0 ||
+ value.length % 4 !== 0 ||
+ !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)
+ ) {
+ return null
+ }
+ const decoded = Buffer.from(value, 'base64')
+ if (decoded.length === 0 || decoded.toString('base64') !== value) return null
+ const token = decoded.toString('utf8')
+ return Buffer.from(token, 'utf8').equals(decoded) && token.length > 0 ? token : null
+ }
+
+ function revisionFor(server: AuthorityMcpServer, secret: AuthoritySecretMetadata | null): string {
+ const material = JSON.stringify({
+ serverUid: server.metadata.uid,
+ serverResourceVersion: server.metadata.resourceVersion,
+ serverDeleting: server.metadata.deletionTimestamp ?? null,
+ authType: server.auth?.type ?? 'none',
+ authSecretRef: server.auth?.secretRef ?? null,
+ authSecretKey: server.auth?.secretKey ?? null,
+ secretUid: secret?.metadata.uid ?? null,
+ secretResourceVersion: secret?.metadata.resourceVersion ?? null,
+ secretDeleting: secret?.metadata.deletionTimestamp ?? null,
+ })
+ return createHash('sha256').update(material).digest('base64url')
+ }
+
+ function sameHostContext(left: AuthorizedHostContext, right: AuthorizedHostContext): boolean {
+ return (
+ left.principal.subject === right.principal.subject &&
+ left.principal.hostName === right.principal.hostName &&
+ left.principal.hostUid === right.principal.hostUid &&
+ left.principal.jti === right.principal.jti &&
+ left.principal.issuedAt === right.principal.issuedAt &&
+ left.principal.expiresAt === right.principal.expiresAt &&
+ left.host.name === right.host.name &&
+ left.host.namespace === right.host.namespace &&
+ left.host.metadata.uid === right.host.metadata.uid &&
+ left.host.metadata.resourceVersion === right.host.metadata.resourceVersion &&
+ left.host.contextRef === right.host.contextRef &&
+ left.context.name === right.context.name &&
+ left.context.namespace === right.context.namespace &&
+ left.context.metadata.uid === right.context.metadata.uid &&
+ left.context.metadata.resourceVersion === right.context.metadata.resourceVersion &&
+ left.context.mcpServers.join('\u0000') === right.context.mcpServers.join('\u0000')
+ )
+ }
+
+ function sameGrant(left: AuthorizedMcpServerGrant, right: AuthorizedMcpServerGrant): boolean {
+ return (
+ sameHostContext(left, right) &&
+ left.server.metadata.uid === right.server.metadata.uid &&
+ left.server.metadata.resourceVersion === right.server.metadata.resourceVersion &&
+ left.credentialRevision === right.credentialRevision
+ )
+ }
+
+ export class McpAuthorizationService {
+ constructor(
+ private readonly store: McpAuthorizationStore,
+ private readonly nowEpochSeconds: () => number = () => Math.floor(Date.now() / 1000)
+ ) {}
+
+ private assertPrincipalLive(principal: VerifiedMcpHostPrincipal): void {
+ if (principal.expiresAt <= this.nowEpochSeconds()) {
+ throw new McpAuthorizationError('unauthorized')
+ }
+ }
+
+ private async resolveHostContext(
+ principal: VerifiedMcpHostPrincipal
+ ): Promise<AuthorizedHostContext> {
+ this.assertPrincipalLive(principal)
+ let host: AuthorityHost | null
+ let context: AuthorityContext | null
+ try {
+ host = await this.store.readHost(principal.hostName)
+ if (
+ !host ||
+ host.name !== principal.hostName ||
+ host.namespace !== principal.namespace ||
+ !isLive(host.metadata) ||
+ host.metadata.uid !== principal.hostUid ||
+ !host.contextRef
+ ) {
+ // A missing/recreated/deleting Host invalidates the authenticated
+ // principal itself. Surface 401 so mcp-host revokes the whole retained
+ // authority set instead of treating this as one missing MCP target.
+ throw new McpAuthorizationError('unauthorized')
+ }
+ context = await this.store.readContext(host.contextRef)
+ } catch (error) {
+ if (error instanceof McpAuthorizationError) throw error
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ if (
+ !context ||
+ context.name !== host.contextRef ||
+ !context.namespace ||
+ !isLive(context.metadata)
+ ) {
+ throw new McpAuthorizationError('not_found')
+ }
+ return { principal, host, context }
+ }
+
+ private async resolveServerGrant(
+ binding: AuthorizedHostContext,
+ serverName: string
+ ): Promise<AuthorizedMcpServerGrant> {
+ if (!binding.context.mcpServers.includes(serverName)) {
+ throw new McpAuthorizationError('not_found')
+ }
+
+ let server: AuthorityMcpServer | null
+ try {
+ server = await this.store.readMcpServer(serverName)
+ } catch {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ if (
+ !server ||
+ server.name !== serverName ||
+ server.namespace !== binding.context.namespace ||
+ !server.enabled ||
+ !isLive(server.metadata)
+ ) {
+ throw new McpAuthorizationError('not_found')
+ }
+
+ const authRequired = Boolean(server.auth && server.auth.type !== 'none')
+ let secretMetadata: AuthoritySecretMetadata | null = null
+ if (authRequired && server.auth?.secretRef) {
+ try {
+ secretMetadata = await this.store.readSecretMetadata(server.auth.secretRef)
+ } catch {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ }
+ if (
+ secretMetadata &&
+ (secretMetadata.name !== server.auth?.secretRef ||
+ secretMetadata.namespace !== server.namespace ||
+ !isLive(secretMetadata.metadata))
+ ) {
+ secretMetadata = null
+ }
+ return {
+ ...binding,
+ server,
+ secretMetadata,
+ credentialRevision: revisionFor(server, secretMetadata),
+ }
+ }
+
+ async listServers(principal: VerifiedMcpHostPrincipal): Promise<AuthorizedMcpServerInfo[]> {
+ const binding = await this.resolveHostContext(principal)
+ const names = [...new Set(binding.context.mcpServers)]
+ const servers: AuthorizedMcpServerInfo[] = []
+ for (const name of names) {
+ let grant: AuthorizedMcpServerGrant
+ try {
+ grant = await this.resolveServerGrant(binding, name)
+ } catch (error) {
+ if (error instanceof McpAuthorizationError && error.code === 'not_found') continue
+ throw error
+ }
+ const authRequired = Boolean(grant.server.auth && grant.server.auth.type !== 'none')
+ const authKind = deriveAuthKind(grant.server.auth, grant.server.oauth, authRequired)
+ servers.push({
+ name: grant.server.name,
+ ...(grant.server.description ? { description: grant.server.description } : {}),
+ transport: toPublicMcpTransport(grant.server.transport),
+ enabled: grant.server.enabled,
+ status: {
+ deployed: grant.server.status.deployed,
+ ready: grant.server.status.ready,
+ ...(typeof grant.server.status.authoritative === 'boolean'
+ ? { authoritative: grant.server.status.authoritative }
+ : {}),
+ },
+ authRequired,
+ ...(authRequired ? { credentialRevision: grant.credentialRevision } : {}),
+ ...(authKind ? { authKind } : {}),
+ })
+ }
+ const revalidated = await this.resolveHostContext(principal)
+ if (!sameHostContext(binding, revalidated)) {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ return servers
+ }
+
+ async getCredential(
+ principal: VerifiedMcpHostPrincipal,
+ serverName: string
+ ): Promise<AuthorizedCredential> {
+ const binding = await this.resolveHostContext(principal)
+ const grant = await this.resolveServerGrant(binding, serverName)
+ const authRequired = Boolean(grant.server.auth && grant.server.auth.type !== 'none')
+ if (!authRequired) {
+ const revalidated = await this.resolveServerGrant(
+ await this.resolveHostContext(principal),
+ serverName
+ )
+ if (!sameGrant(grant, revalidated)) {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ this.assertPrincipalLive(principal)
+ return { token: null, credentialRevision: grant.credentialRevision }
+ }
+
+ if (!grant.server.auth?.secretRef || !grant.secretMetadata) {
+ throw new McpAuthorizationError('credential_unavailable')
+ }
+ let secret: AuthoritySecret | null
+ try {
+ secret = await this.store.readSecret(grant.server.auth.secretRef)
+ } catch {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ if (
+ !secret ||
+ secret.name !== grant.secretMetadata.name ||
+ secret.namespace !== grant.secretMetadata.namespace ||
+ !isLive(secret.metadata) ||
+ secret.metadata.uid !== grant.secretMetadata.metadata.uid ||
+ secret.metadata.resourceVersion !== grant.secretMetadata.metadata.resourceVersion ||
+ secret.metadata.deletionTimestamp !== grant.secretMetadata.metadata.deletionTimestamp
+ ) {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ const selectedSecretKey = selectSecretKey(secret, grant.server.auth.secretKey)
+ if (!selectedSecretKey) throw new McpAuthorizationError('credential_unavailable')
+ const token = decodeBase64Credential(secret.data[selectedSecretKey])
+ if (!token) throw new McpAuthorizationError('credential_unavailable')
+
+ const revalidated = await this.resolveServerGrant(
+ await this.resolveHostContext(principal),
+ serverName
+ )
+ if (!sameGrant(grant, revalidated)) {
+ throw new McpAuthorizationError('authorization_unavailable')
+ }
+ this.assertPrincipalLive(principal)
+ return { token, credentialRevision: grant.credentialRevision }
+ }
+ }
diff --cc mcp-host/src/agent/taskExecutor.ts
index 1c534fc6a,15e78e095..7034c8ee4
--- a/mcp-host/src/agent/taskExecutor.ts
+++ b/mcp-host/src/agent/taskExecutor.ts
@@@ -17,11 -18,8 +18,12 @@@ import { LlmError, LlmErrorCode } from
import { ApprovalController } from '../core/extensions/approvalController'
import type { ApprovalConfig } from '../core/extensions/approvalTypes'
import { PressureContextManager } from '../core/extensions/contextManager'
-import { UnifiedApprovalGateController } from '../core/extensions/mcpApprovalGateController'
+import {
+ UnifiedApprovalGateController,
+ buildConnectRequiredApproval,
+ extractConnectRequiredMarker,
+} from '../core/extensions/mcpApprovalGateController'
+ import { type GuardrailsConfig, buildToolLaneGuardrail } from '../core/guardrails'
import type { AgentEventEmitter, LlmPort, LoopController, ToolRegistry } from '../core/interfaces'
import { DeferrableToolController } from '../core/orchestration/deferrableToolController'
import type { SimpleEventEmitter } from '../core/orchestration/eventEmitter'
diff --cc mcp-host/src/contextMapperClient.test.ts
index 61c78e97c,6a8da3626..ed0aae40f
--- a/mcp-host/src/contextMapperClient.test.ts
+++ b/mcp-host/src/contextMapperClient.test.ts
@@@ -61,69 -264,88 +264,92 @@@ describe('ContextMapperClient Host-scop
)
)
)
- const client = new ContextMapperClient('http://context-mapper.test')
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: authentication(),
+ })
- await expect(client.listServersByContext('production')).resolves.toEqual([])
+ await expect(client.pollServers()).rejects.toThrow(
+ 'HCC inventory response contains forbidden authority metadata'
+ )
})
- it('does not convert a failed all-server request into an authoritative empty fleet', async () => {
- const networkError = new Error('connection reset')
- vi.stubGlobal('fetch', vi.fn().mockRejectedValue(networkError))
- const client = new ContextMapperClient('http://context-mapper.test')
+ it('preserves a valid authKind from the v2 inventory (mini-spec 10 §3.3)', async () => {
+ vi.stubGlobal(
+ 'fetch',
- vi.fn().mockResolvedValue(
- new Response(
- JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-user' })])),
- { status: 200 }
++ vi
++ .fn()
++ .mockResolvedValue(
++ new Response(JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-user' })])), {
++ status: 200,
++ })
+ )
- )
+ )
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: authentication(),
+ })
- await expect(client.listAllServers()).rejects.toBe(networkError)
+ const result = await client.pollServers()
+ expect(result.servers[0].authKind).toBe('oauth-user')
})
- it('does not convert an unavailable controller into an authoritative empty fleet', async () => {
- // The rejection case above never reaches the `!response.ok` branch, so a
- // 503 from an unready controller was uncovered: swapping that throw for
- // `return []` left the whole suite green while turning "I cannot tell you"
- // into an authoritative "there are none".
+ it('rejects an authKind value outside the enum', async () => {
vi.stubGlobal(
'fetch',
- vi.fn().mockResolvedValue(
- new Response(
- JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-admin' })])),
- { status: 200 }
+ vi
+ .fn()
- .mockResolvedValue(new Response('', { status: 503, statusText: 'Service Unavailable' }))
++ .mockResolvedValue(
++ new Response(JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-admin' })])), {
++ status: 200,
++ })
+ )
- )
)
- const client = new ContextMapperClient('http://context-mapper.test')
-
- await expect(client.listAllServers()).rejects.toThrow(/503/)
- })
- })
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: authentication(),
+ })
- describe('ContextMapperClient.pollServers', () => {
- afterEach(() => {
- vi.restoreAllMocks()
- vi.unstubAllGlobals()
+ await expect(client.pollServers()).rejects.toThrow(
+ 'HCC inventory response contains an invalid authKind'
+ )
})
- it('rejects an HTTP 503 instead of fabricating an authoritative empty fleet', async () => {
+ it('still rejects forbidden metadata even when a valid authKind is present (guard intact, I1)', async () => {
vi.stubGlobal(
'fetch',
-- vi.fn().mockResolvedValue(
-- new Response(
- JSON.stringify({
- error: 'Service Unavailable',
- message: 'Context mapper provider inventory is not authoritative',
- }),
- { status: 503, statusText: 'Service Unavailable' }
- JSON.stringify(
- inventory([
- authorizedServer({ authKind: 'oauth-context', contextRef: 'foreign-context' }),
- ])
- ),
- { status: 200 }
++ vi
++ .fn()
++ .mockResolvedValue(
++ new Response(
++ JSON.stringify(
++ inventory([
++ authorizedServer({ authKind: 'oauth-context', contextRef: 'foreign-context' }),
++ ])
++ ),
++ { status: 200 }
++ )
)
-- )
)
- const client = new ContextMapperClient('http://context-mapper.test')
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: authentication(),
+ })
- await expect(client.pollServers('production')).rejects.toThrow('HTTP 503: Service Unavailable')
+ await expect(client.pollServers()).rejects.toThrow(
+ 'HCC inventory response contains forbidden authority metadata'
+ )
})
- it('rejects a network failure instead of fabricating an authoritative empty fleet', async () => {
- const networkError = new Error('connection reset')
- vi.stubGlobal('fetch', vi.fn().mockRejectedValue(networkError))
- const client = new ContextMapperClient('http://context-mapper.test')
+ it('accepts an authenticated HTTP 200 empty inventory as authoritative', async () => {
+ vi.stubGlobal(
+ 'fetch',
+ vi.fn().mockResolvedValue(new Response(JSON.stringify(inventory([])), { status: 200 }))
+ )
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: authentication(),
+ })
- await expect(client.pollServers('production')).rejects.toBe(networkError)
+ await expect(client.pollServers()).resolves.toEqual(inventory([]))
})
- it('bounds a silent HCC request so authoritative polling cannot stall indefinitely', async () => {
+ it('bounds a silent authenticated HCC request', async () => {
vi.stubGlobal(
'fetch',
vi.fn().mockImplementation((_url: string, init?: RequestInit) => {
diff --cc mcp-host/src/core/orchestration/toolUseLoopToolBatch.ts
index 428a95599,43edd09b1..bba81bb71
--- a/mcp-host/src/core/orchestration/toolUseLoopToolBatch.ts
+++ b/mcp-host/src/core/orchestration/toolUseLoopToolBatch.ts
@@@ -1,8 -1,11 +1,15 @@@
+ import { randomUUID } from 'crypto'
import { extractToolIntent, getDisplayName } from '../../progress/intentExtraction.js'
+import {
+ buildConnectRequiredApproval,
+ extractConnectRequiredMarker,
+} from '../extensions/mcpApprovalGateController'
+ import {
+ type ToolIdentity,
+ recordAndCheck,
+ recordDecision,
+ resolveToolIdentityFromRegistry,
+ } from '../guardrails'
import type { ChatMessage, PendingApproval, TokenUsage, ToolCall, ToolResult } from '../types'
import type { LoopConfig } from './loopConfig'
import { executeSingleTool, reportToolComplete, reportToolStart } from './toolUseLoopSingleTool'
@@@ -256,10 -391,23 +395,25 @@@ export async function executeToolCalls
}
const progressStart = reportToolStart(config, call, iteration, i, calls.length, llmTextContent)
- const toolResult = await executeSingleTool(call, config, iteration)
+ let toolResult = await executeSingleTool(call, config, iteration)
+
+ // PostToolUse redaction (spec §6.2 / §10 #3): installed `post_tool_use` hooks
+ // may redact the model-visible result `content` (never `is_error`). Only the
+ // LLM-message `content` is touched — `rawContent` (UI preview) is left intact.
++ // Applied here — before the abort push, the U5 connect-required suspend, and
++ // the main push below — so every downstream consumer sees the redacted result.
+ if (config.guardrails?.transformResult && toolIdentity) {
+ const view = await config.guardrails.transformResult(toolIdentity, call.arguments, {
+ content: toolResult.content,
+ isError: toolResult.is_error,
+ })
+ if (view.content !== toolResult.content) {
+ toolResult = { ...toolResult, content: view.content }
+ }
+ }
- toolResults.push(toolResult)
if (config.abortSignal?.aborted) {
+ toolResults.push(toolResult)
return { toolResults, cancelled: true }
}
diff --cc mcp-host/src/main.ts
index 9aa43190d,5ce8ac4ce..f042a1034
--- a/mcp-host/src/main.ts
+++ b/mcp-host/src/main.ts
@@@ -80,7 -84,15 +84,15 @@@ import
replaceAuthoritativeMcpFleet,
runAuthoritativeMcpInitialization,
} from './mcp/authoritativeFleet'
-import { type BrokerTokenProviderDeps, createBrokerTokenProvider } from './mcp/brokerTokenProvider'
+ import {
+ createMcpAuthorityStalenessDeadline,
+ handleMcpAuthorityPollFailure,
+ isMcpAuthorityStale,
+ revokeMcpAuthorityState,
+ } from './mcp/authorityLifecycle'
+ import type { HandleMcpAuthorityPollFailureOptions } from './mcp/authorityLifecycle'
+import { type BrokerTokenProviderDeps, createBrokerTokenProvider } from './mcp/brokerTokenProvider'
+ import { McpStatusHeartbeat } from './mcp/statusHeartbeat'
import { startMcpInitializationInBackground } from './mcpBackgroundInit'
import { IncomingMessageHandler, PendingTaskEntry } from './messageHandler'
import {
diff --cc mcp-host/src/mcp/__tests__/authorityLifecycle.test.ts
index 000000000,30d2a525f..451cffab2
mode 000000,100644..100644
--- a/mcp-host/src/mcp/__tests__/authorityLifecycle.test.ts
+++ b/mcp-host/src/mcp/__tests__/authorityLifecycle.test.ts
@@@ -1,0 -1,372 +1,376 @@@
+ import { afterEach, describe, expect, it, vi } from 'vitest'
+ import { ContextMapperClient, ContextMapperRequestError } from '../../contextMapperClient'
+ import type { McpServerInfo } from '../../types'
+ import { AuthoritativeMcpFleetCoordinator } from '../authoritativeFleet'
+ import {
+ createMcpAuthorityStalenessDeadline,
+ handleMcpAuthorityPollFailure,
+ revokeMcpAuthorityState,
+ } from '../authorityLifecycle'
+ import { McpClient } from '../client'
+ import { McpManager, SHARED_PRINCIPAL, serializeClientKey } from '../manager'
+
+ const securedServer: McpServerInfo = {
+ name: 'secured-server',
+ transport: { type: 'streamableHttp', url: 'http://secured-server.test/mcp' },
+ enabled: true,
+ authRequired: true,
+ credentialRevision: 'credential-revision-1',
+ status: { deployed: true, ready: true, authoritative: true },
+ }
+
+ function deferred(): { promise: Promise<void>; resolve(): void } {
+ let resolve!: () => void
+ const promise = new Promise<void>(resolvePromise => {
+ resolve = resolvePromise
+ })
+ return { promise, resolve }
+ }
+
+ function retainedClient(
+ manager: McpManager,
+ serverName = securedServer.name
+ ): McpClient | undefined {
+ return (
+ manager as unknown as {
+ clients: Map<string, McpClient>
+ }
+ ).clients.get(serializeClientKey(serverName, SHARED_PRINCIPAL))
+ }
+
+ function pendingClient(
+ manager: McpManager,
+ serverName = securedServer.name
+ ): McpClient | undefined {
+ return (
+ manager as unknown as {
+ pendingAdmissions: Map<string, { client: McpClient }>
+ }
+ ).pendingAdmissions.get(serializeClientKey(serverName, SHARED_PRINCIPAL))?.client
+ }
+
+ function createLifecycleHarness(
+ manager: McpManager,
+ coordinator = new AuthoritativeMcpFleetCoordinator(1, 1, true)
+ ) {
+ let currentManager: McpManager | null = manager
+ let serverState = new Map([[securedServer.name, 'credential-revision-1']])
+ let lastSuccessAt = 10_000
+ let generation = 7
+ let pollerRunning = true
+ let clearDeadline: () => void = () => undefined
+ const effects: string[] = []
+ const reasons: string[] = []
+
+ const originalCloseManager = coordinator.closeManager.bind(coordinator)
+ vi.spyOn(coordinator, 'closeManager').mockImplementation(closingManager => {
+ effects.push('coordinator-close')
+ originalCloseManager(closingManager)
+ })
+ const originalScheduleCleanup = coordinator.scheduleCleanup.bind(coordinator)
+ vi.spyOn(coordinator, 'scheduleCleanup').mockImplementation(cleanup => {
+ effects.push('cleanup-scheduled')
+ originalScheduleCleanup(cleanup)
+ })
+ const originalManagerClose = manager.close.bind(manager)
+ vi.spyOn(manager, 'close').mockImplementation(scheduleCleanup => {
+ effects.push('manager-close')
+ return originalManagerClose(scheduleCleanup)
+ })
+
+ const revoke = (reason: string, restartPolling: boolean): void => {
+ reasons.push(reason)
+ revokeMcpAuthorityState({
+ reason,
+ restartPolling,
+ invalidateInitialization: () => {
+ effects.push('generation-invalidated')
+ generation += 1
+ },
+ stopPolling: () => {
+ effects.push('polling-stopped')
+ pollerRunning = false
+ },
+ clearStalenessDeadline: () => {
+ effects.push('deadline-cleared')
+ clearDeadline()
+ },
+ withdrawManager: () => {
+ effects.push('manager-withdrawn')
+ const closingManager = currentManager
+ currentManager = null
+ return closingManager
+ },
+ clearServerState: () => {
+ effects.push('server-state-cleared')
+ serverState = new Map()
+ },
+ clearLastSuccess: () => {
+ effects.push('last-success-cleared')
+ lastSuccessAt = 0
+ },
+ coordinator,
+ onCleanupFailure: () => effects.push('cleanup-failed'),
+ onRevoked: () => effects.push('revoked'),
+ shouldRestartPolling: () => true,
+ startPolling: () => {
+ effects.push('polling-started')
+ pollerRunning = true
+ },
+ })
+ }
+
+ return {
+ coordinator,
+ effects,
+ reasons,
+ revoke,
+ setDeadlineClear: (clear: () => void) => {
+ clearDeadline = clear
+ },
+ state: () => ({
+ currentManager,
+ serverState,
+ lastSuccessAt,
+ generation,
+ pollerRunning,
+ }),
+ }
+ }
+
+ async function captureError(effect: () => Promise<unknown>): Promise<unknown> {
+ try {
+ await effect()
+ } catch (error) {
+ return error
+ }
+ throw new Error('Expected operation to reject')
+ }
+
+ describe('MCP authority lifecycle', () => {
+ afterEach(() => {
+ vi.restoreAllMocks()
+ vi.unstubAllGlobals()
+ vi.useRealTimers()
+ })
+
+ it.each([
+ { status: 401 as const, expectedFetches: 2, expectedRefreshes: 1 },
+ { status: 403 as const, expectedFetches: 1, expectedRefreshes: 0 },
+ ])(
+ 'withdraws the live fleet synchronously and restarts polling after persistent $status',
+ async ({ status, expectedFetches, expectedRefreshes }) => {
+ vi.spyOn(McpClient.prototype, 'connect').mockImplementation(async function (this: McpClient) {
+ // Mimic the real connect's JIT token resolution so the post-revoke wipe
+ // assertion below exercises currentAuthToken.
+ ;(this as unknown as { currentAuthToken?: string }).currentAuthToken = await (
+ this as unknown as { tokenProvider?: { resolve(): Promise<string | undefined> } }
+ ).tokenProvider?.resolve()
+ ;(this as unknown as { connected: boolean }).connected = true
+ })
+ const manager = new McpManager()
+ await manager.addServer(securedServer, 'sensitive-upstream-bearer')
+ const installedClient = retainedClient(manager)
+ expect(installedClient).toBeDefined()
+
+ const harness = createLifecycleHarness(manager)
+ harness.coordinator.publishSnapshot(manager, [securedServer])
+ const refresh = vi.fn().mockResolvedValue(undefined)
+ const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status }))
+ vi.stubGlobal('fetch', fetchMock)
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: {
+ getAccessToken: () => 'host-access-token',
+ refreshOnUnauthorized: refresh,
+ onCallerAuthorizationFailure: rejectedStatus =>
+ harness.revoke(`caller_${rejectedStatus}`, true),
+ },
+ })
+
+ const error = await captureError(() => client.pollServers())
+ expect(error).toBeInstanceOf(ContextMapperRequestError)
+ const disposition = handleMcpAuthorityPollFailure(error, {
+ hasPublishedManager: () => harness.state().currentManager !== null,
+ lastSuccessAt: () => harness.state().lastSuccessAt,
+ now: () => 70_000,
+ maxStalenessMs: 60_000,
+ revoke: harness.revoke,
+ onCallerAuthorizationRejected: vi.fn(),
+ onInventoryAuthorityRevoked: vi.fn(),
+ onUnavailable: vi.fn(),
+ })
+
+ expect(disposition).toBe('caller_authorization_rejected')
+ expect(fetchMock).toHaveBeenCalledTimes(expectedFetches)
+ expect(refresh).toHaveBeenCalledTimes(expectedRefreshes)
+ expect(harness.reasons).toEqual([`caller_${status}`])
+ expect(harness.state()).toMatchObject({
+ currentManager: null,
+ lastSuccessAt: 0,
+ generation: 8,
+ pollerRunning: true,
+ })
+ expect(harness.state().serverState.size).toBe(0)
- expect((installedClient as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()
++ expect(
++ (installedClient as unknown as { currentAuthToken?: string }).currentAuthToken
++ ).toBeUndefined()
+ expect(manager.getConnectedServers()).toEqual([])
+ expect(manager.getKnownServers()).toEqual([])
+ expect(harness.effects).toEqual([
+ 'generation-invalidated',
+ 'polling-stopped',
+ 'deadline-cleared',
+ 'manager-withdrawn',
+ 'server-state-cleared',
+ 'last-success-cleared',
+ 'coordinator-close',
+ 'manager-close',
+ 'cleanup-scheduled',
+ 'revoked',
+ 'polling-started',
+ ])
+ await expect(manager.addServer(securedServer, 'new-bearer')).resolves.toBe('stale')
+ await harness.coordinator.drainCleanups()
+ }
+ )
+
+ it('classifies an actual inventory 404 as complete authority revocation', async () => {
+ const manager = new McpManager()
+ const harness = createLifecycleHarness(manager)
+ harness.coordinator.publishSnapshot(manager, [securedServer])
+ vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(null, { status: 404 })))
+ const client = new ContextMapperClient('http://context-mapper.test', {
+ authentication: {
+ getAccessToken: () => 'host-access-token',
+ refreshOnUnauthorized: vi.fn(),
+ onCallerAuthorizationFailure: vi.fn(),
+ },
+ })
+ const error = await captureError(() => client.pollServers())
+ const inventoryRevoked = vi.fn()
+
+ const disposition = handleMcpAuthorityPollFailure(error, {
+ hasPublishedManager: () => harness.state().currentManager !== null,
+ lastSuccessAt: () => harness.state().lastSuccessAt,
+ now: () => 70_000,
+ maxStalenessMs: 60_000,
+ revoke: harness.revoke,
+ onCallerAuthorizationRejected: vi.fn(),
+ onInventoryAuthorityRevoked: inventoryRevoked,
+ onUnavailable: vi.fn(),
+ })
+
+ expect(disposition).toBe('inventory_not_found')
+ expect(inventoryRevoked).toHaveBeenCalledTimes(1)
+ expect(harness.reasons).toEqual(['inventory_not_found'])
+ expect(harness.state()).toMatchObject({ currentManager: null, pollerRunning: true })
+ await harness.coordinator.drainCleanups()
+ })
+
+ it('revokes the full state at the absolute staleness deadline and restarts recovery polling', () => {
+ vi.useFakeTimers()
+ vi.setSystemTime(new Date('2026-08-20T00:00:00.000Z'))
+ const manager = new McpManager()
+ const harness = createLifecycleHarness(manager)
+ harness.coordinator.publishSnapshot(manager, [securedServer])
+ const deadline = createMcpAuthorityStalenessDeadline(60_000, () =>
+ harness.revoke('authority_stale_deadline', true)
+ )
+ harness.setDeadlineClear(deadline.clear)
+
+ deadline.recordSuccess()
+ vi.advanceTimersByTime(60_000)
+
+ expect(harness.reasons).toEqual(['authority_stale_deadline'])
+ expect(harness.state()).toMatchObject({
+ currentManager: null,
+ lastSuccessAt: 0,
+ generation: 8,
+ pollerRunning: true,
+ })
+ expect(harness.state().serverState.size).toBe(0)
+ })
+
+ it('revokes an unavailable stale fleet through the poll-error path', async () => {
+ const manager = new McpManager()
+ const harness = createLifecycleHarness(manager)
+ harness.coordinator.publishSnapshot(manager, [securedServer])
+ const unavailable = vi.fn()
+
+ const disposition = handleMcpAuthorityPollFailure(new Error('transport unavailable'), {
+ hasPublishedManager: () => harness.state().currentManager !== null,
+ lastSuccessAt: () => harness.state().lastSuccessAt,
+ now: () => 70_000,
+ maxStalenessMs: 60_000,
+ revoke: harness.revoke,
+ onCallerAuthorizationRejected: vi.fn(),
+ onInventoryAuthorityRevoked: vi.fn(),
+ onUnavailable: unavailable,
+ })
+
+ expect(disposition).toBe('authority_stale')
+ expect(unavailable).toHaveBeenCalledTimes(1)
+ expect(harness.reasons).toEqual(['authority_stale'])
+ expect(harness.state()).toMatchObject({ currentManager: null, pollerRunning: true })
+ await harness.coordinator.drainCleanups()
+ })
+
+ it('fences a delayed admission so revocation cannot republish its bearer or tools', async () => {
+ const connectStarted = deferred()
+ const releaseConnect = deferred()
+ vi.spyOn(McpClient.prototype, 'connect').mockImplementation(async function (this: McpClient) {
+ // Mimic the real connect's JIT token resolution before the transport pause
+ // so the fencing assertions (bearer held, then wiped) observe it.
+ ;(this as unknown as { currentAuthToken?: string }).currentAuthToken = await (
+ this as unknown as { tokenProvider?: { resolve(): Promise<string | undefined> } }
+ ).tokenProvider?.resolve()
+ connectStarted.resolve()
+ await releaseConnect.promise
+ if ((this as unknown as { retired: boolean }).retired) {
+ throw new Error('MCP client is closed')
+ }
+ ;(this as unknown as { connected: boolean }).connected = true
+ })
+ const manager = new McpManager()
+ const coordinator = new AuthoritativeMcpFleetCoordinator(1, 1, true)
+ const lease = coordinator.publishSnapshot(manager, [securedServer])
+ const harness = createLifecycleHarness(manager, coordinator)
+ const committed = vi.fn()
+ let outcome: string | undefined
+ const admission = coordinator.runAdmission(
+ manager,
+ securedServer.name,
+ lease,
+ async isCurrent => {
+ outcome = await manager.addServer(securedServer, 'late-sensitive-bearer', {
+ isCurrent,
+ onCommit: committed,
+ scheduleCleanup: cleanup => coordinator.scheduleCleanup(cleanup),
+ })
+ }
+ )
+
+ await connectStarted.promise
+ const candidate = pendingClient(manager)
+ expect(candidate).toBeDefined()
- expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBe('late-sensitive-bearer')
++ expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBe(
++ 'late-sensitive-bearer'
++ )
+
+ harness.revoke('caller_403', true)
+
+ expect(harness.state().currentManager).toBeNull()
+ expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()
+ expect(manager.getConnectedServers()).toEqual([])
+ expect(manager.getKnownServers()).toEqual([])
+ releaseConnect.resolve()
+ await admission
+ await coordinator.drainCleanups()
+
+ expect(outcome).toBe('stale')
+ expect(committed).not.toHaveBeenCalled()
+ expect(manager.getAllTools()).toEqual([])
+ expect(manager.getConnectedServers()).toEqual([])
+ expect(harness.state().currentManager).toBeNull()
+ })
+ })
diff --cc mcp-host/src/mcp/__tests__/authorizationRevocation.test.ts
index 000000000,39c526a8b..451ac9292
mode 000000,100644..100644
--- a/mcp-host/src/mcp/__tests__/authorizationRevocation.test.ts
+++ b/mcp-host/src/mcp/__tests__/authorizationRevocation.test.ts
@@@ -1,0 -1,31 +1,29 @@@
+ import { describe, expect, it } from 'vitest'
+ import type { McpServerInfo } from '../../types'
+ import { McpClient, staticTokenProvider } from '../client'
+
+ const server: McpServerInfo = {
+ name: 'scoped-server',
+ transport: { type: 'streamableHttp', url: 'http://scoped-server.test/mcp' },
+ enabled: true,
+ authRequired: true,
+ credentialRevision: 'credential-revision-1',
+ status: { deployed: true, ready: true },
+ }
+
+ describe('MCP credential revocation', () => {
+ it('wipes the retained bearer synchronously when a client is retired', async () => {
+ const client = new McpClient(server, staticTokenProvider('sensitive-upstream-bearer'))
+ // Simulate a live connection: connect() resolves the provider into
+ // currentAuthToken, which retire() must clear synchronously. Seed it
+ // directly so the assertion exercises retire()'s wipe, not the unconnected
+ // (already-undefined) state.
+ ;(client as unknown as { currentAuthToken?: string }).currentAuthToken =
+ 'sensitive-upstream-bearer'
+
+ const cleanup = client.retire()
+
- expect(
- (client as unknown as { currentAuthToken?: string }).currentAuthToken
- ).toBeUndefined()
++ expect((client as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()
+ await expect(cleanup()).resolves.toBeUndefined()
+ })
+ })
diff --cc mcp-host/src/mcp/client.ts
index 80185879f,bae29aa0b..ec53d8616
--- a/mcp-host/src/mcp/client.ts
+++ b/mcp-host/src/mcp/client.ts
@@@ -5,13 -5,19 +5,19 @@@
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+ import { ListToolsResultSchema } from '@modelcontextprotocol/sdk/types.js'
import { McpServerInfo, McpTool } from '../types'
-import { extractStructuredHttpStatus, isAuthError } from './serverStatus'
+ import {
+ type McpToolCallOptions,
+ ensureNotAborted,
+ remainingBudgetMs,
+ requestOptions,
+ resolveMcpRequestTimeoutMs,
+ withRequestTimeout,
+ } from './requestOptions'
+import { extractStructuredHttpStatus, isAuthError } from './serverStatus'
- const DEFAULT_MCP_TOOL_TIMEOUT_MS = 3_600_000
- const DEFAULT_MCP_TOOL_MAX_TOTAL_TIMEOUT_MS = 3_600_000
- const MCP_TOOL_TIMEOUT_ENV = 'CLERUM_MCP_TOOL_TIMEOUT_MS'
- const MCP_TOOL_MAX_TOTAL_TIMEOUT_ENV = 'CLERUM_MCP_TOOL_MAX_TOTAL_TIMEOUT_MS'
+ export type { McpToolCallOptions } from './requestOptions'
type SupportedMcpTransport = SSEClientTransport | StreamableHTTPClientTransport
@@@ -63,12 -59,7 +59,6 @@@ export class McpAuthError extends Erro
}
}
- interface McpSdkRequestOptions {
- timeout: number
- maxTotalTimeout: number
- signal?: AbortSignal
- }
--
interface McpCallRecovery {
sourceEpoch: number
sourceClient: Client