Skip to content

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

TypeScript
7.9 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import { ConfigStore, PROVIDER_ENV_NAMES } from '../../config/configStore'
import { ALL_PROVIDERS, type LlmProvider, descriptorFor } from '../../llm/registryCore'
import { agentToolEnvProvider } from '../agentToolEnv'

/** Build a full, valid secret payload for a provider from its registry slots. */
function secretForProvider(provider: LlmProvider): Record<string, string> {
  const data: Record<string, string> = {}
  for (const slot of descriptorFor(provider).credentialSlots) {
    data[slot.dataKey] = `secret-${slot.dataKey}`
  }
  return data
}

// ─── Test doubles ─────────────────────────────────────────────────────
// Mirror config/configStore.test.ts so we exercise a REAL ConfigStore: the
// boundary we lock here is the difference between snapshot() and
// userEnvSnapshot(), which only a real store can demonstrate.

interface FakeWatchHandle {
  abort: () => void
}

function makeFakeWatch(): { watch: ReturnType<typeof vi.fn> } {
  const watch = vi.fn(
    async (
      path: string,
      params: { fieldSelector?: string },
      _onEvent: (type: string, obj: unknown) => void,
      _onDone: (err: Error | null | undefined) => void
    ) => {
      const handle: FakeWatchHandle = { abort: () => undefined }
      void path
      void params
      return { abort: handle.abort }
    }
  )
  return { watch }
}

function makeFakeCoreApi(initial: {
  secrets?: Record<string, Record<string, string>>
  configMaps?: Record<string, Record<string, string>>
}) {
  const secrets = { ...(initial.secrets ?? {}) }
  const configMaps = { ...(initial.configMaps ?? {}) }
  return {
    readNamespacedSecret: vi.fn(async (req: { name: string }) => {
      const data = secrets[req.name]
      if (!data) throw { code: 404, statusCode: 404 }
      return { data }
    }),
    readNamespacedConfigMap: vi.fn(async (req: { name: string }) => {
      const data = configMaps[req.name]
      if (!data) throw { code: 404, statusCode: 404 }
      return { data }
    }),
  }
}

function build(opts: {
  provider: LlmProvider
  secrets?: Record<string, Record<string, string>>
  configMaps?: Record<string, Record<string, string>>
}): ConfigStore {
  const watch = makeFakeWatch()
  const api = makeFakeCoreApi({ secrets: opts.secrets, configMaps: opts.configMaps })
  return new ConfigStore({
    namespace: 'mcp-host',
    hostRef: 'trader',
    llmSecretRef: 'chatllm-api-keys',
    provider: opts.provider,
    coreApi: api as unknown as ConstructorParameters<typeof ConfigStore>[0]['coreApi'],
    watch: watch as unknown as ConstructorParameters<typeof ConfigStore>[0]['watch'],
  })
}

// ─── Tests ────────────────────────────────────────────────────────────

describe('agentToolEnvProvider', () => {
  let store: ConfigStore | null = null

  afterEach(() => {
    store?.stop()
    store = null
  })

  it('exposes non-provider secrets but NEVER the provider API key (catches snapshot() regression)', async () => {
    store = build({
      provider: 'openai',
      secrets: {
        'chatllm-api-keys': { 'openai-api-key': 'sk-openai' },
        'host-trader-env-secret': { GITHUB_TOKEN: 'ghp_secret' },
      },
    })
    await store.start()

    const toolEnv = agentToolEnvProvider(store)
    // Non-provider secret must flow through to tool subprocesses.
    expect(toolEnv.GITHUB_TOKEN).toBe('ghp_secret')
    // Provider API key must NOT be in the tool env.
    expect(toolEnv).not.toHaveProperty('OPENAI_API_KEY')

    // Prove the difference is real: snapshot() DOES carry the provider key, so a
    // regression that wires agentToolEnvProvider to snapshot() would fail above.
    const full = store.snapshot()
    expect(full.OPENAI_API_KEY).toBe('sk-openai')
    expect(full.GITHUB_TOKEN).toBe('ghp_secret')
  })

  it.each(ALL_PROVIDERS)(
    'redacts EVERY credential slot env var for every provider (registry-derived): %s',
    async provider => {
      store = build({
        provider,
        secrets: { 'chatllm-api-keys': secretForProvider(provider) },
      })
      await store.start()

      const toolEnv = agentToolEnvProvider(store)
      // Every slot of the configured provider must be gone (multi-slot: Bedrock
      // has TWO — both must be absent, not just the primary).
      for (const slot of descriptorFor(provider).credentialSlots) {
        expect(toolEnv, `provider=${provider} leaked ${slot.envName}`).not.toHaveProperty(
          slot.envName
        )
      }
      // Defense-in-depth: NONE of the known provider slot env names leak.
      for (const envName of PROVIDER_ENV_NAMES) {
        expect(toolEnv, `provider=${provider} leaked ${envName}`).not.toHaveProperty(envName)
      }
    }
  )

  it('leak test — N credentials of DIFFERENT providers present, only one active: none reach the subprocess', async () => {
    // The Secret carries credentials for four providers simultaneously: openai +
    // claude API keys, the Vertex service-account JSON, and BOTH Bedrock AWS
    // keys. Only `bedrock` is the active provider. The boundary must exclude
    // every provider credential (spec §3-R4.3), not just the active one's.
    store = build({
      provider: 'bedrock',
      secrets: {
        'chatllm-api-keys': {
          'openai-api-key': 'sk-openai',
          'claude-api-key': 'sk-ant-claude',
          'vertex-service-account-json': '{"client_email":"x","private_key":"y"}',
          'aws-access-key-id': 'AKIAEXAMPLE',
          'aws-secret-access-key': 'aws-secret-value',
        },
        'host-trader-env-secret': { GITHUB_TOKEN: 'ghp_secret' },
      },
    })
    await store.start()

    const toolEnv = agentToolEnvProvider(store)
    // Non-provider secret still flows through.
    expect(toolEnv.GITHUB_TOKEN).toBe('ghp_secret')
    // Not one provider credential env name — for ANY provider — is present.
    for (const envName of PROVIDER_ENV_NAMES) {
      expect(toolEnv, `leaked ${envName}`).not.toHaveProperty(envName)
    }
    // And no credential VALUE leaks under any key either.
    const values = Object.values(toolEnv)
    for (const secret of [
      'sk-openai',
      'sk-ant-claude',
      'AKIAEXAMPLE',
      'aws-secret-value',
      '{"client_email":"x","private_key":"y"}',
    ]) {
      expect(values, `leaked value ${secret}`).not.toContain(secret)
    }
  })

  it('excludes a provider credential env name even when injected via a NON-llm tier (registry-wide RESERVED)', async () => {
    // A misconfiguration/attack puts a provider credential env NAME into the
    // per-Host env secret while a DIFFERENT provider is active. The registry
    // half of the boundary (RESERVED_SECRET_ENV_NAMES) must still strip it —
    // the exclusion is registry-wide, not "active provider only".
    store = build({
      provider: 'openai',
      secrets: {
        'chatllm-api-keys': { 'openai-api-key': 'sk-openai' },
        'host-trader-env-secret': {
          AWS_SECRET_ACCESS_KEY: 'sneaky-aws-secret',
          CLAUDE_API_KEY: 'sneaky-claude',
          GITHUB_TOKEN: 'ghp_secret',
        },
      },
    })
    await store.start()

    const toolEnv = agentToolEnvProvider(store)
    expect(toolEnv.GITHUB_TOKEN).toBe('ghp_secret')
    // Injected provider credential names are stripped despite coming from the
    // host-secret tier, not the active provider's llm-secret slots.
    expect(toolEnv).not.toHaveProperty('AWS_SECRET_ACCESS_KEY')
    expect(toolEnv).not.toHaveProperty('CLAUDE_API_KEY')
    expect(Object.values(toolEnv)).not.toContain('sneaky-aws-secret')
    expect(Object.values(toolEnv)).not.toContain('sneaky-claude')
  })

  it('returns {} for null/undefined store', () => {
    expect(agentToolEnvProvider(null)).toEqual({})
    expect(agentToolEnvProvider(undefined)).toEqual({})
  })
})