Skip to content

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

TypeScript

fix(hcc): skip no-op Service replaces at all four writers (#460)

Alfredo Lopez81c9d5e8a8ba
diff --git a/host-context-controller/package-lock.json b/host-context-controller/package-lock.json
index f406d893c..c7d20368b 100644
--- a/host-context-controller/package-lock.json
+++ b/host-context-controller/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-host-context-controller",
- "version": "0.1.240",
+ "version": "0.1.241",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-host-context-controller",
- "version": "0.1.240",
+ "version": "0.1.241",
"license": "SEE LICENSE IN LICENSE",
"dependencies": {
"@clerum/image-policy": "file:../packages/image-policy",
diff --git a/host-context-controller/package.json b/host-context-controller/package.json
index f98cd3935..6209f2f48 100644
--- a/host-context-controller/package.json
+++ b/host-context-controller/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-host-context-controller",
- "version": "0.1.240",
+ "version": "0.1.241",
"description": "Host Context Controller - provides McpServer CRDs to mcp-host via REST API",
"main": "dist/main.js",
"engines": {
diff --git a/host-context-controller/src/__tests__/channelReaderServiceNoopGate.test.ts b/host-context-controller/src/__tests__/channelReaderServiceNoopGate.test.ts
new file mode 100644
index 000000000..d4ddeee42
--- /dev/null
+++ b/host-context-controller/src/__tests__/channelReaderServiceNoopGate.test.ts
@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import {
+ type MockCoreApi,
+ asAppsApi,
+ asCoreApi,
+ asCustomApi,
+ asNetworkingApi,
+ asRbacApi,
+ createMockAppsApi,
+ createMockCoreApi,
+ createMockCustomApi,
+ createMockNetworkingApi,
+ createMockRbacApi,
+} from '../../test/__fixtures__/testMocks'
+import { HostReconciler } from '../hostReconciler'
+import type { HostCRD } from '../types'
+
+function makeStubKc(): k8s.KubeConfig {
+ const stub = new Proxy({}, { get: () => vi.fn() })
+ return { makeApiClient: () => stub } as unknown as k8s.KubeConfig
+}
+
+function makeHost(): HostCRD {
+ return {
+ name: 'chatllm',
+ namespace: 'mcp-host',
+ uid: 'chatllm-uid',
+ spec: {
+ host: 'chatllm',
+ contextRef: 'ctx',
+ secretRef: 'secret',
+ },
+ }
+}
+
+function asApiserverService(desired: k8s.V1Service, drift?: { port?: number }): k8s.V1Service {
+ const ports = (desired.spec?.ports ?? []).map(port => ({
+ protocol: 'TCP' as const,
+ name: port.name,
+ port: drift?.port ?? port.port,
+ targetPort: port.targetPort,
+ }))
+ return {
+ spec: {
+ clusterIP: '10.96.20.4',
+ clusterIPs: ['10.96.20.4'],
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ internalTrafficPolicy: 'Cluster',
+ ipFamilyPolicy: 'SingleStack',
+ ipFamilies: ['IPv4'],
+ selector: desired.spec?.selector,
+ ports,
+ },
+ status: { loadBalancer: {} },
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: {
+ resourceVersion: '1783416',
+ uid: '22222222-3333-4444-5555-666666666666',
+ creationTimestamp: '2026-04-01T00:00:00.000Z',
+ generation: 1,
+ managedFields: [{ manager: 'kube-apiserver', operation: 'Update' }],
+ selfLink: '/api/v1/namespaces/channels/services/channel-reader-chatllm',
+ name: desired.metadata?.name,
+ namespace: desired.metadata?.namespace,
+ labels: desired.metadata?.labels,
+ annotations: { 'kubectl.kubernetes.io/last-applied-configuration': '{}' },
+ },
+ }
+}
+
+function updatedServiceLogs(log: ReturnType<typeof vi.spyOn>, needle: string): string[] {
+ return log.mock.calls
+ .map(call => String(call[0]))
+ .filter(line => line.includes('Updated') && line.includes(needle))
+}
+
+describe('channel-reader Service no-op gate', () => {
+ let coreApi: MockCoreApi
+ let reconciler: HostReconciler
+ const host = makeHost()
+
+ beforeEach(() => {
+ coreApi = createMockCoreApi()
+ reconciler = new HostReconciler(makeStubKc(), {
+ coreApi: asCoreApi(coreApi),
+ appsApi: asAppsApi(createMockAppsApi()),
+ networkingApi: asNetworkingApi(createMockNetworkingApi()),
+ rbacApi: asRbacApi(createMockRbacApi()),
+ customApi: asCustomApi(createMockCustomApi()),
+ })
+ })
+
+ it('NOOP-CRS-1 / LOG-SVC-1: equivalent named targetPort handoff skips replace', async () => {
+ const desired = (reconciler as any).buildChannelReaderService(host) as k8s.V1Service
+ expect(desired.spec?.ports?.[0]?.targetPort).toBe('handoff')
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).reconcileChannelReaderService(host)
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ expect(updatedServiceLogs(log, 'channel-reader Service "channel-reader-chatllm"')).toEqual([])
+ } finally {
+ log.mockRestore()
+ }
+ })
+
+ it('NOOP-CRS-2 / LOG-SVC-2: port drift replaces once and logs once', async () => {
+ const desired = (reconciler as any).buildChannelReaderService(host) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired, { port: 8100 }))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).reconcileChannelReaderService(host)
+ expect(coreApi.replaceNamespacedService).toHaveBeenCalledOnce()
+ expect(updatedServiceLogs(log, 'channel-reader Service "channel-reader-chatllm"')).toEqual([
+ '[HostReconciler] Updated channel-reader Service "channel-reader-chatllm"',
+ ])
+ } finally {
+ log.mockRestore()
+ }
+ })
+})
diff --git a/host-context-controller/src/__tests__/hostServiceNoopGate.test.ts b/host-context-controller/src/__tests__/hostServiceNoopGate.test.ts
new file mode 100644
index 000000000..f27265950
--- /dev/null
+++ b/host-context-controller/src/__tests__/hostServiceNoopGate.test.ts
@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import {
+ type MockCoreApi,
+ asAppsApi,
+ asCoreApi,
+ asCustomApi,
+ asNetworkingApi,
+ asRbacApi,
+ createMockAppsApi,
+ createMockCoreApi,
+ createMockCustomApi,
+ createMockNetworkingApi,
+ createMockRbacApi,
+} from '../../test/__fixtures__/testMocks'
+import { HostReconciler } from '../hostReconciler'
+import type { HostCRD } from '../types'
+
+function makeStubKc(): k8s.KubeConfig {
+ const stub = new Proxy({}, { get: () => vi.fn() })
+ return { makeApiClient: () => stub } as unknown as k8s.KubeConfig
+}
+
+function makeHost(): HostCRD {
+ return {
+ name: 'chatllm',
+ namespace: 'mcp-host',
+ uid: 'chatllm-uid',
+ spec: {
+ host: 'chatllm',
+ contextRef: 'ctx',
+ secretRef: 'secret',
+ },
+ }
+}
+
+function asApiserverService(desired: k8s.V1Service, drift?: { port?: number }): k8s.V1Service {
+ const ports = (desired.spec?.ports ?? []).map(port => ({
+ protocol: 'TCP' as const,
+ name: port.name,
+ port: drift?.port ?? port.port,
+ targetPort: port.targetPort,
+ }))
+ return {
+ spec: {
+ clusterIP: '10.96.14.7',
+ clusterIPs: ['10.96.14.7'],
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ internalTrafficPolicy: 'Cluster',
+ ipFamilyPolicy: 'SingleStack',
+ ipFamilies: ['IPv4'],
+ selector: desired.spec?.selector,
+ ports,
+ },
+ status: { loadBalancer: {} },
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: {
+ resourceVersion: '1776125',
+ uid: '11111111-2222-3333-4444-555555555555',
+ creationTimestamp: '2026-04-01T00:00:00.000Z',
+ generation: 1,
+ managedFields: [{ manager: 'kube-apiserver', operation: 'Update' }],
+ selfLink: '/api/v1/namespaces/mcp-host/services/chatllm',
+ name: desired.metadata?.name,
+ namespace: desired.metadata?.namespace,
+ labels: desired.metadata?.labels,
+ annotations: { 'kubectl.kubernetes.io/last-applied-configuration': '{}' },
+ },
+ }
+}
+
+function updatedServiceLogs(log: ReturnType<typeof vi.spyOn>, needle: string): string[] {
+ return log.mock.calls
+ .map(call => String(call[0]))
+ .filter(line => line.includes('Updated') && line.includes(needle))
+}
+
+describe('Host ensureService no-op gate', () => {
+ let coreApi: MockCoreApi
+ let reconciler: HostReconciler
+ const host = makeHost()
+
+ beforeEach(() => {
+ coreApi = createMockCoreApi()
+ reconciler = new HostReconciler(makeStubKc(), {
+ coreApi: asCoreApi(coreApi),
+ appsApi: asAppsApi(createMockAppsApi()),
+ networkingApi: asNetworkingApi(createMockNetworkingApi()),
+ rbacApi: asRbacApi(createMockRbacApi()),
+ customApi: asCustomApi(createMockCustomApi()),
+ })
+ })
+
+ it('CREATE-SVC-1: successful create never reads or replaces', async () => {
+ await (reconciler as any).ensureService(host)
+ expect(coreApi.createNamespacedService).toHaveBeenCalledOnce()
+ expect(coreApi.readNamespacedService).not.toHaveBeenCalled()
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ })
+
+ it('NOOP-SVC-1 / LOG-SVC-1: equivalent Service skips replace and Updated logs', async () => {
+ const desired = (reconciler as any).buildService(host) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(host)
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ expect(updatedServiceLogs(log, 'Service "chatllm"')).toEqual([])
+ } finally {
+ log.mockRestore()
+ }
+ })
+
+ it('NOOP-SVC-2 / LOG-SVC-2: port drift replaces once and logs once', async () => {
+ const desired = (reconciler as any).buildService(host) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired, { port: 9090 }))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(host)
+ expect(coreApi.replaceNamespacedService).toHaveBeenCalledOnce()
+ expect(updatedServiceLogs(log, 'Service "chatllm"')).toEqual([
+ '[HostReconciler] Updated Service "chatllm"',
+ ])
+ } finally {
+ log.mockRestore()
+ }
+ })
+})
diff --git a/host-context-controller/src/__tests__/llmHookServiceNoopGate.test.ts b/host-context-controller/src/__tests__/llmHookServiceNoopGate.test.ts
new file mode 100644
index 000000000..5f792e9e1
--- /dev/null
+++ b/host-context-controller/src/__tests__/llmHookServiceNoopGate.test.ts
@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import {
+ type MockCoreApi,
+ asAppsApi,
+ asCoreApi,
+ asCustomApi,
+ asNetworkingApi,
+ createMockAppsApi,
+ createMockCoreApi,
+ createMockCustomApi,
+ createMockNetworkingApi,
+} from '../../test/__fixtures__/testMocks'
+import { config } from '../config'
+import { LlmHookReconciler, computePodKey } from '../llmHookReconciler'
+import type { HostCRD, LlmHookCRD } from '../types'
+
+const IMG = 'registry.example.com/hook@sha256:' + 'a'.repeat(64)
+
+function makeHook(): LlmHookCRD {
+ return {
+ name: 'pre-hook',
+ namespace: config.llmHooksNamespace,
+ generation: 1,
+ spec: {
+ target: { image: { ref: IMG, port: 8080 } },
+ path: '/',
+ lifecyclePoints: ['preCall'],
+ },
+ }
+}
+
+function asApiserverService(desired: k8s.V1Service, drift?: { port?: number }): k8s.V1Service {
+ const ports = (desired.spec?.ports ?? []).map(port => ({
+ protocol: 'TCP' as const,
+ name: port.name,
+ port: drift?.port ?? port.port,
+ targetPort: port.targetPort,
+ }))
+ return {
+ spec: {
+ clusterIP: '10.96.40.2',
+ clusterIPs: ['10.96.40.2'],
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ internalTrafficPolicy: 'Cluster',
+ ipFamilyPolicy: 'SingleStack',
+ ipFamilies: ['IPv4'],
+ selector: desired.spec?.selector,
+ ports,
+ },
+ status: { loadBalancer: {} },
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: {
+ resourceVersion: '4',
+ uid: '44444444-5555-6666-7777-888888888888',
+ creationTimestamp: '2026-04-01T00:00:00.000Z',
+ generation: 1,
+ managedFields: [{ manager: 'kube-apiserver', operation: 'Update' }],
+ name: desired.metadata?.name,
+ namespace: desired.metadata?.namespace,
+ labels: desired.metadata?.labels,
+ annotations: { 'kubectl.kubernetes.io/last-applied-configuration': '{}' },
+ },
+ }
+}
+
+function updatedServiceLogs(log: ReturnType<typeof vi.spyOn>, needle: string): string[] {
+ return log.mock.calls
+ .map(call => String(call[0]))
+ .filter(line => line.includes('Updated') && line.includes(needle))
+}
+
+describe('LlmHook ensureService no-op gate', () => {
+ let coreApi: MockCoreApi
+ let reconciler: LlmHookReconciler
+ const hook = makeHook()
+ const podKey = computePodKey(hook)!
+ const port = hook.spec.target.image!.port
+
+ beforeEach(() => {
+ coreApi = createMockCoreApi()
+ reconciler = new LlmHookReconciler(
+ {} as k8s.KubeConfig,
+ new Map<string, LlmHookCRD>(),
+ new Map<string, HostCRD>(),
+ {
+ appsApi: asAppsApi(createMockAppsApi()),
+ coreApi: asCoreApi(coreApi),
+ customApi: asCustomApi(createMockCustomApi()),
+ networkingApi: asNetworkingApi(createMockNetworkingApi()),
+ }
+ )
+ })
+
+ it('NOOP-LLMSVC-1 / LOG-SVC-1: equivalent Service skips replace and Updated logs', async () => {
+ const desired = (reconciler as any).buildService(podKey, port) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(podKey, port)
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ expect(updatedServiceLogs(log, `Service "${desired.metadata?.name}"`)).toEqual([])
+ } finally {
+ log.mockRestore()
+ }
+ })
+
+ it('NOOP-LLMSVC-2 / LOG-SVC-2: port drift replaces once and logs once', async () => {
+ const desired = (reconciler as any).buildService(podKey, port) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired, { port: 9090 }))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(podKey, port)
+ expect(coreApi.replaceNamespacedService).toHaveBeenCalledOnce()
+ expect(updatedServiceLogs(log, `Service "${desired.metadata?.name}"`)).toEqual([
+ `[LlmHook] Updated Service "${desired.metadata?.name}"`,
+ ])
+ } finally {
+ log.mockRestore()
+ }
+ })
+})
diff --git a/host-context-controller/src/__tests__/mcpServerServiceNoopGate.test.ts b/host-context-controller/src/__tests__/mcpServerServiceNoopGate.test.ts
new file mode 100644
index 000000000..8152891f2
--- /dev/null
+++ b/host-context-controller/src/__tests__/mcpServerServiceNoopGate.test.ts
@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import {
+ type MockCoreApi,
+ asAppsApi,
+ asCoreApi,
+ asCustomApi,
+ createMockAppsApi,
+ createMockCoreApi,
+ createMockCustomApi,
+} from '../../test/__fixtures__/testMocks'
+import { McpServerReconciler } from '../reconciler'
+import type { McpServerCRD } from '../types'
+
+function makeServer(): McpServerCRD {
+ return {
+ name: 'test-mcp',
+ namespace: 'mcp-server',
+ uid: 'uid-test-1234',
+ spec: {
+ contextRef: 'ctx1',
+ image: 'my-mcp-server:v1',
+ transport: { type: 'streamableHttp', port: 3000, url: 'http://test.mcp-server.svc:3000/mcp' },
+ },
+ }
+}
+
+function asApiserverService(desired: k8s.V1Service, drift?: { port?: number }): k8s.V1Service {
+ const ports = (desired.spec?.ports ?? []).map(port => ({
+ protocol: 'TCP' as const,
+ name: port.name,
+ port: drift?.port ?? port.port,
+ targetPort: port.targetPort,
+ }))
+ return {
+ spec: {
+ clusterIP: '10.96.30.8',
+ clusterIPs: ['10.96.30.8'],
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ internalTrafficPolicy: 'Cluster',
+ ipFamilyPolicy: 'SingleStack',
+ ipFamilies: ['IPv4'],
+ selector: desired.spec?.selector,
+ ports,
+ },
+ status: { loadBalancer: {} },
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: {
+ resourceVersion: '12',
+ uid: '33333333-4444-5555-6666-777777777777',
+ creationTimestamp: '2026-04-01T00:00:00.000Z',
+ generation: 1,
+ managedFields: [{ manager: 'kube-apiserver', operation: 'Update' }],
+ name: desired.metadata?.name,
+ namespace: desired.metadata?.namespace,
+ labels: desired.metadata?.labels,
+ annotations: desired.metadata?.annotations,
+ ownerReferences: desired.metadata?.ownerReferences,
+ },
+ }
+}
+
+function updatedServiceLogs(log: ReturnType<typeof vi.spyOn>, needle: string): string[] {
+ return log.mock.calls
+ .map(call => String(call[0]))
+ .filter(line => line.includes('Updated') && line.includes(needle))
+}
+
+describe('McpServer ensureService no-op gate', () => {
+ let coreApi: MockCoreApi
+ let reconciler: McpServerReconciler
+ const server = makeServer()
+
+ beforeEach(() => {
+ coreApi = createMockCoreApi()
+ reconciler = new McpServerReconciler({} as k8s.KubeConfig, {
+ assumeInventoryAuthorityWhenUnconfigured: true,
+ appsApi: asAppsApi(createMockAppsApi()),
+ coreApi: asCoreApi(coreApi),
+ customApi: asCustomApi(createMockCustomApi()),
+ })
+ })
+
+ it('NOOP-MCPSVC-1 / LOG-SVC-1: equivalent Service skips replace and Updated logs', async () => {
+ const desired = (reconciler as any).buildService(server) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(server)
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ expect(updatedServiceLogs(log, 'Service "test-mcp"')).toEqual([])
+ } finally {
+ log.mockRestore()
+ }
+ })
+
+ it('NOOP-MCPSVC-2 / LOG-SVC-2: port drift replaces once and logs once', async () => {
+ const desired = (reconciler as any).buildService(server) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired, { port: 4000 }))
+ const log = vi.spyOn(console, 'log')
+ try {
+ await (reconciler as any).ensureService(server)
+ expect(coreApi.replaceNamespacedService).toHaveBeenCalledOnce()
+ expect(updatedServiceLogs(log, 'Service "test-mcp"')).toEqual([
+ '[Reconciler] Updated Service "test-mcp"',
+ ])
+ } finally {
+ log.mockRestore()
+ }
+ })
+
+ it('GATE-MCP-1: drift plus isCurrent false skips replace after the gate', async () => {
+ const desired = (reconciler as any).buildService(server) as k8s.V1Service
+ coreApi.createNamespacedService.mockRejectedValue({ code: 409 })
+ coreApi.readNamespacedService.mockResolvedValue(asApiserverService(desired, { port: 4000 }))
+ const isCurrent = vi.fn().mockReturnValueOnce(true).mockReturnValue(false)
+
+ await (reconciler as any).ensureService(server, isCurrent)
+
+ expect(coreApi.replaceNamespacedService).not.toHaveBeenCalled()
+ expect(isCurrent).toHaveBeenCalled()
+ })
+})
diff --git a/host-context-controller/src/__tests__/replaceWithConflictRetryOrder.test.ts b/host-context-controller/src/__tests__/replaceWithConflictRetryOrder.test.ts
new file mode 100644
index 000000000..007789645
--- /dev/null
+++ b/host-context-controller/src/__tests__/replaceWithConflictRetryOrder.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import { preserveServiceAssignedFields, replaceWithConflictRetry } from '../utils'
+
+const desired: k8s.V1Service = {
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: { name: 'svc', namespace: 'ns', labels: { app: 'svc' } },
+ spec: { selector: { app: 'svc' }, ports: [{ name: 'http', port: 8080 }] },
+}
+
+const existing: k8s.V1Service = {
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: {
+ name: 'svc',
+ namespace: 'ns',
+ labels: { app: 'svc' },
+ resourceVersion: '9',
+ uid: 'uid-svc',
+ },
+ spec: {
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ clusterIP: '10.96.14.7',
+ selector: { app: 'svc' },
+ ports: [{ name: 'http', port: 8080, protocol: 'TCP' }],
+ },
+ status: { loadBalancer: {} },
+}
+
+describe('replaceWithConflictRetry order and retry', () => {
+ it('ORDER-1: validateExisting throws before isUpToDate is consulted', async () => {
+ const replace = vi.fn()
+ const isUpToDate = vi.fn(() => true)
+ const validateExisting = vi.fn(() => {
+ throw new Error('unsafe to replace')
+ })
+
+ await expect(
+ replaceWithConflictRetry({
+ description: 'Service "svc"',
+ logPrefix: '[Test]',
+ body: desired,
+ mergeExisting: preserveServiceAssignedFields,
+ isUpToDate,
+ validateExisting,
+ read: async () => existing,
+ replace,
+ })
+ ).rejects.toThrow('unsafe to replace')
+
+ expect(validateExisting).toHaveBeenCalledOnce()
+ expect(isUpToDate).not.toHaveBeenCalled()
+ expect(replace).not.toHaveBeenCalled()
+ })
+
+ it('RETRY-SVC-1: 409 then success logs after 2 attempts', async () => {
+ const replace = vi.fn().mockRejectedValueOnce({ code: 409 }).mockResolvedValueOnce({})
+ const log = vi.spyOn(console, 'log')
+ try {
+ await replaceWithConflictRetry({
+ description: 'Service "svc"',
+ logPrefix: '[Test]',
+ body: desired,
+ mergeExisting: preserveServiceAssignedFields,
+ isUpToDate: () => false,
+ read: async () => existing,
+ replace,
+ })
+
+ expect(replace).toHaveBeenCalledTimes(2)
+ const updated = log.mock.calls
+ .map(call => String(call[0]))
+ .filter(line => line.includes('[Test] Updated Service "svc"'))
+ expect(updated).toEqual(['[Test] Updated Service "svc" (after 2 attempts)'])
+ } finally {
+ log.mockRestore()
+ }
+ })
+})
diff --git a/host-context-controller/src/__tests__/serviceMatchesDesired.test.ts b/host-context-controller/src/__tests__/serviceMatchesDesired.test.ts
new file mode 100644
index 000000000..1be555f07
--- /dev/null
+++ b/host-context-controller/src/__tests__/serviceMatchesDesired.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest'
+import type * as k8s from '@kubernetes/client-node'
+import { preserveServiceAssignedFields, serviceMatchesDesired } from '../utils'
+
+function desiredService(overrides: Partial<k8s.V1Service> = {}): k8s.V1Service {
+ return {
+ apiVersion: 'v1',
+ kind: 'Service',
+ metadata: { name: 'svc', namespace: 'ns', labels: { app: 'svc' } },
+ spec: {
+ selector: { app: 'svc' },
+ ports: [{ name: 'http', port: 8080 }],
+ },
+ ...overrides,
+ }
+}
+
+function merged(desired: k8s.V1Service, existing: k8s.V1Service): k8s.V1Service {
+ return preserveServiceAssignedFields(
+ {
+ ...desired,
+ metadata: { ...desired.metadata, resourceVersion: existing.metadata?.resourceVersion },
+ },
+ existing
+ )
+}
+
+describe('serviceMatchesDesired', () => {
+ it('CMP-1: server defaults and omitted targetPort=port compare equal', () => {
+ const desired = desiredService()
+ const existing: k8s.V1Service = {
+ kind: 'Service',
+ apiVersion: 'v1',
+ spec: {
+ type: 'ClusterIP',
+ sessionAffinity: 'None',
+ internalTrafficPolicy: 'Cluster',
+ clusterIP: '10.96.14.7',
+ clusterIPs: ['10.96.14.7'],
+ ipFamilyPolicy: 'SingleStack',
+ ipFamilies: ['IPv4'],
+ selector: { app: 'svc' },
+ ports: [{ protocol: 'TCP', name: 'http', port: 8080, targetPort: 8080 }],
+ },
+ status: { loadBalancer: {} },
+ metadata: {
+ resourceVersion: '1776125',
+ uid: '11111111-2222-3333-4444-555555555555',
+ creationTimestamp: '2026-04-01T00:00:00.000Z',
+ generation: 1,
+ managedFields: [{ manager: 'kube-apiserver', operation: 'Update' }],
+ selfLink: '/api/v1/namespaces/ns/services/svc',
+ name: 'svc',
+ namespace: 'ns',
+ labels: { app: 'svc' },
+ },
+ }
+
+ expect(serviceMatchesDesired(merged(desired, existing), existing)).toBe(true)
+ })
+
+ it('CMP-2: label diff and a desired annotation are not equivalent', () => {
+ const existing = desiredService()
+ const labelDrift = desiredService({
+ metadata: { name: 'svc', namespace: 'ns', labels: { app: 'other' } },
+ })
+ expect(serviceMatchesDesired(merged(labelDrift, existing), existing)).toBe(false)
+
+ const annotated = desiredService({
+ metadata: {
+ name: 'svc',
+ namespace: 'ns',
+ labels: { app: 'svc' },
+ annotations: { 'clerum.io/note': 'added' },
+ },
+ })
+ expect(serviceMatchesDesired(merged(annotated, existing), existing)).toBe(false)
+ })
+
+ it('CMP-3: named versus numeric targetPort is a mismatch', () => {
+ const desired = desiredService({
+ spec: {
+ selector: { app: 'svc' },
+ ports: [{ name: 'http', port: 8080, targetPort: 'http' }],
+ },
+ })
+ const existing = desiredService({
+ spec: {
+ selector: { app: 'svc' },
+ ports: [{ name: 'http', port: 8080, targetPort: 8080 }],
+ },
+ })
+ expect(serviceMatchesDesired(merged(desired, existing), existing)).toBe(false)
+ })
+
+ it('CMP-4: reordered ports are not sorted and compare unequal', () => {
+ const desired = desiredService({
+ spec: {
+ selector: { app: 'svc' },
+ ports: [
+ { name: 'http', port: 8080 },
+ { name: 'desktop', port: 3000 },
+ ],
+ },
+ })
+ const existing = desiredService({
+ spec: {
+ selector: { app: 'svc' },
+ ports: [
+ { name: 'desktop', port: 3000 },
+ { name: 'http', port: 8080 },
+ ],
+ },
+ })
+ expect(serviceMatchesDesired(merged(desired, existing), existing)).toBe(false)
+ })
+
+ it('CMP-5: missing spec or undefined shapes fail open to write', () => {
+ const desired = desiredService()
+ expect(serviceMatchesDesired(desired, { metadata: { name: 'svc' } })).toBe(false)
+ expect(serviceMatchesDesired(desired, undefined as unknown as k8s.V1Service)).toBe(false)
+ })
+})
diff --git a/host-context-controller/src/hostReconciler.ts b/host-context-controller/src/hostReconciler.ts
index ec5ecab59..9d42f94d7 100644
--- a/host-context-controller/src/hostReconciler.ts
+++ b/host-context-controller/src/hostReconciler.ts
@@ -60,6 +60,7 @@ import {
preserveDeploymentAnnotations,
preserveServiceAssignedFields,
replaceWithConflictRetry,
+ serviceMatchesDesired,
} from './utils'
export type { EffectiveHostLifecycle } from './statelessLifecycle.types'
@@ -2219,6 +2220,7 @@ export class HostReconciler {
logPrefix: '[HostReconciler]',
body: service,
mergeExisting: preserveServiceAssignedFields,
+ isUpToDate: serviceMatchesDesired,
read: () => this.coreApi.readNamespacedService({ name, namespace: ns }),
replace: body =>
this.coreApi.replaceNamespacedService({
@@ -2227,7 +2229,6 @@ export class HostReconciler {
body,
}),
})
- console.log(`[HostReconciler] Updated channel-reader Service "${name}"`)
} catch (replaceErr) {
console.error(
`[HostReconciler] Failed to update channel-reader Service "${name}":`,
@@ -3064,6 +3065,7 @@ export class HostReconciler {
logPrefix: '[HostReconciler]',
body: service,
mergeExisting: preserveServiceAssignedFields,
+ isUpToDate: serviceMatchesDesired,
read: () =>
this.coreApi.readNamespacedService({
namespace: host.namespace,
@@ -3076,7 +3078,6 @@ export class HostReconciler {
body,
}),
})
- console.log(`[HostReconciler] Updated Service "${host.name}"`)
} catch (updateError) {
console.error(`[HostReconciler] Failed to update Service "${host.name}":`, updateError)
}
diff --git a/host-context-controller/src/llmHookReconciler.ts b/host-context-controller/src/llmHookReconciler.ts
index 43080b055..c9c62f9a4 100644
--- a/host-context-controller/src/llmHookReconciler.ts
+++ b/host-context-controller/src/llmHookReconciler.ts
@@ -43,6 +43,7 @@ import {
preserveObjectAnnotations,
preserveServiceAssignedFields,
replaceWithConflictRetry,
+ serviceMatchesDesired,
} from './utils'
const GROUP = 'clerum.io'
@@ -795,6 +796,7 @@ export class LlmHookReconciler {
logPrefix: LOG,
body: service,
mergeExisting: preserveServiceAssignedFields,
+ isUpToDate: serviceMatchesDesired,
read: () => this.coreApi.readNamespacedService({ name, namespace: config.llmHooksNamespace }),
replace: body =>
this.coreApi.replaceNamespacedService({ name, namespace: config.llmHooksNamespace, body }),
diff --git a/host-context-controller/src/reconciler.ts b/host-context-controller/src/reconciler.ts
index 077dac09f..c1cb7d7e2 100644
--- a/host-context-controller/src/reconciler.ts
+++ b/host-context-controller/src/reconciler.ts
@@ -34,6 +34,7 @@ import {
preserveObjectAnnotations,
preserveServiceAssignedFields,
replaceWithConflictRetry,
+ serviceMatchesDesired,
} from './utils'
/**
@@ -1547,6 +1548,7 @@ ${authHeaderLines ? '\n # ── Credential auth headers (envsubst-resolv
logPrefix: '[Reconciler]',
body: service,
mergeExisting: preserveServiceAssignedFields,
+ isUpToDate: serviceMatchesDesired,
read: () =>
this.coreApi.readNamespacedService({
name: server.name,
diff --git a/host-context-controller/src/utils.ts b/host-context-controller/src/utils.ts
index a6992eeb8..3ce72d136 100644
--- a/host-context-controller/src/utils.ts
+++ b/host-context-controller/src/utils.ts
@@ -173,6 +173,68 @@ export function preserveServiceAssignedFields<
}
}
+/**
+ * True when the merged desired Service is equivalent to the live object, so a
+ * replace would be a no-op. Canonicalize first: the apiserver default-fills
+ * type/sessionAffinity/internalTrafficPolicy/protocol and omitted targetPort,
+ * and key order is not stable (#307). Arrays stay in author order (#214).
+ * Doubt or a malformed object returns false (fail-open-to-write).
+ */
+export function serviceMatchesDesired(
+ desired: k8s.V1Service | undefined,
+ existing: k8s.V1Service | undefined
+): boolean {
+ try {
+ if (!desired?.spec || !existing?.spec) return false
+ return (
+ JSON.stringify(normalizeServiceForComparison(desired)) ===
+ JSON.stringify(normalizeServiceForComparison(existing))
+ )
+ } catch {
+ return false
+ }
+}
+
+export function normalizeServiceForComparison(service: k8s.V1Service): unknown {
+ const normalized = structuredClone(service)
+ delete normalized.status
+ delete normalized.metadata?.resourceVersion
+ delete normalized.metadata?.uid
+ delete normalized.metadata?.generation
+ delete normalized.metadata?.creationTimestamp
+ delete normalized.metadata?.managedFields
+ delete normalized.metadata?.selfLink
+
+ const spec = normalized.spec
+ if (spec) {
+ if (spec.type === 'ClusterIP') delete spec.type
+ if (spec.sessionAffinity === 'None') delete spec.sessionAffinity
+ if (spec.internalTrafficPolicy === 'Cluster') delete spec.internalTrafficPolicy
+ for (const port of spec.ports ?? []) {
+ if (port.protocol === 'TCP') delete port.protocol
+ if (port.targetPort === undefined) port.targetPort = port.port
+ }
+ }
+
+ return normalizeServiceValue(normalized)
+}
+
+function normalizeServiceValue(value: unknown): unknown {
+ if (Array.isArray(value)) return value.map(normalizeServiceValue)
+ if (!isServiceObject(value)) return value
+
+ const normalized: Record<string, unknown> = {}
+ for (const key of Object.keys(value).sort()) {
+ const entry = value[key]
+ if (entry !== undefined) normalized[key] = normalizeServiceValue(entry)
+ }
+ return normalized
+}
+
+function isServiceObject(value: unknown): value is Record<string, unknown> {
+ return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
/** Create-or-replace a NetworkPolicy (409 catch → conflict-retry replace). */
export async function applyNetworkPolicy(
api: k8s.NetworkingV1Api,