Skip to content

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

TypeScript
6.9 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'

// In-memory keychain backing the mocked keytar module. Keyed by service:account
// so per-environment account isolation is directly observable.
const keychain = new Map<string, string>()
const keyOf = (service: string, account: string) => `${service}::${account}`

vi.mock('keytar', () => ({
  getPassword: vi.fn(async (service: string, account: string) =>
    keychain.has(keyOf(service, account)) ? keychain.get(keyOf(service, account))! : null
  ),
  setPassword: vi.fn(async (service: string, account: string, password: string) => {
    keychain.set(keyOf(service, account), password)
  }),
  deletePassword: vi.fn(async (service: string, account: string) =>
    keychain.delete(keyOf(service, account))
  ),
}))

// app.isReady()=false + safeStorage unavailable ⇒ the keytar path is the only
// active store, which is exactly what we want to assert per-env isolation on.
vi.mock('electron', () => ({
  app: { isReady: vi.fn(() => false), getPath: vi.fn(() => '/tmp/evenfire-test') },
  safeStorage: { isEncryptionAvailable: vi.fn(() => false) },
}))

const SERVICE = 'Evenfire'
const LEGACY_ACCOUNT = 'session-token'
// Realistic env keys: `resolveEnvKey` emits `<slug>-<12 hex>` where the slug is
// `[a-z0-9_]+` (non-alphanumerics collapsed to `_`), so the ONLY `-` is the
// hash separator.
const ENV_A = 'env_a-000000000000'
const ENV_B = 'env_b-111111111111'
const ENV_A_WITH_RPC = 'env_a_rpc-222222222222'

let TokenStore: typeof import('../tokenStore.js').TokenStore

beforeEach(async () => {
  keychain.clear()
  TokenStore = (await import('../tokenStore.js')).TokenStore
})

describe('TokenStore per-environment slots (spec §5.2)', () => {
  it('stores and reads a token under the env-scoped account', async () => {
    const store = new TokenStore()
    await store.setSessionToken('tok-a', ENV_A)
    expect(await store.getSessionToken(ENV_A)).toBe('tok-a')
    // Physically stored under the namespaced account, never the global one.
    expect(keychain.get(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`))).toBe('tok-a')
    expect(keychain.has(keyOf(SERVICE, LEGACY_ACCOUNT))).toBe(false)
  })

  it('does not leak env A token into env B', async () => {
    const store = new TokenStore()
    await store.setSessionToken('tok-a', ENV_A)
    expect(await store.getSessionToken(ENV_B)).toBeNull()

    await store.setSessionToken('tok-b', ENV_B)
    expect(await store.getSessionToken(ENV_A)).toBe('tok-a')
    expect(await store.getSessionToken(ENV_B)).toBe('tok-b')
  })

  it('clear only removes the active env slot (other env token survives)', async () => {
    const store = new TokenStore()
    await store.setSessionToken('tok-a', ENV_A)
    await store.setSessionToken('tok-b', ENV_B)

    await store.clearSessionToken(ENV_A)
    expect(await store.getSessionToken(ENV_A)).toBeNull()
    expect(await store.getSessionToken(ENV_B)).toBe('tok-b')
  })

  it('continues scoped cleanup when keytar deletePassword throws synchronously', async () => {
    const keytar = await import('keytar')
    vi.mocked(keytar.deletePassword).mockImplementationOnce(() => {
      throw new Error('synchronous keychain failure')
    })
    const store = new TokenStore()

    await expect(store.clearSessionToken(ENV_A)).resolves.toBeUndefined()
    expect(keytar.deletePassword).toHaveBeenCalledWith(SERVICE, LEGACY_ACCOUNT)
  })

  it('clear removes explicitly supported legacy environment alias slots', async () => {
    const store = new TokenStore()
    await store.setSessionToken('legacy-token', ENV_A)
    await store.setSessionToken('current-token', ENV_A_WITH_RPC)

    await store.clearSessionToken(ENV_A_WITH_RPC, { legacyEnvKeys: [ENV_A] })

    expect(keychain.has(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`))).toBe(false)
    expect(keychain.has(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A_WITH_RPC}`))).toBe(false)
    expect(await store.getSessionToken(ENV_A_WITH_RPC)).toBeNull()
    expect(await store.getSessionToken(ENV_A)).toBeNull()
  })

  it('can clear one environment without touching the legacy global token slot', async () => {
    keychain.set(keyOf(SERVICE, LEGACY_ACCOUNT), 'legacy-token')
    await new TokenStore().setSessionToken('rest-only-token', ENV_A)
    const store = new TokenStore()

    await store.clearSessionToken(ENV_A, { clearLegacyGlobalSlot: false })

    expect(keychain.has(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`))).toBe(false)
    expect(keychain.get(keyOf(SERVICE, LEGACY_ACCOUNT))).toBe('legacy-token')
  })

  it('migrates a legacy global-slot token into the active env slot, then deletes it', async () => {
    // Simulate a pre-per-env install: token in the single global account.
    keychain.set(keyOf(SERVICE, LEGACY_ACCOUNT), 'legacy-tok')
    const store = new TokenStore()

    const migrated = await store.getSessionToken(ENV_A)
    expect(migrated).toBe('legacy-tok')
    // Copied into the env slot and removed from the legacy slot (no cross-env reuse).
    expect(keychain.get(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`))).toBe('legacy-tok')
    expect(keychain.has(keyOf(SERVICE, LEGACY_ACCOUNT))).toBe(false)

    // A second env no longer sees the (now-consumed) legacy token.
    expect(await store.getSessionToken(ENV_B)).toBeNull()
  })

  it('migrates an older env-scoped token into the active env slot, then deletes it', async () => {
    keychain.set(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`), 'rest-only-tok')
    const store = new TokenStore()

    const migrated = await store.getSessionToken(ENV_A_WITH_RPC, { legacyEnvKeys: [ENV_A] })
    expect(migrated).toBe('rest-only-tok')
    expect(keychain.get(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A_WITH_RPC}`))).toBe(
      'rest-only-tok'
    )
    expect(keychain.has(keyOf(SERVICE, `${LEGACY_ACCOUNT}::${ENV_A}`))).toBe(false)
    expect(await store.getSessionToken(ENV_A)).toBeNull()
  })

  it('clear removes the legacy global slot too (defense against later migration)', async () => {
    keychain.set(keyOf(SERVICE, LEGACY_ACCOUNT), 'legacy-tok')
    const store = new TokenStore()
    await store.setSessionToken('tok-a', ENV_A)

    await store.clearSessionToken(ENV_A)
    expect(keychain.has(keyOf(SERVICE, LEGACY_ACCOUNT))).toBe(false)
  })

  it('rejects a malformed envKey before it reaches account/file names', async () => {
    const store = new TokenStore()
    // Path-separator, traversal, wrong shape, and empty are all refused up front
    // so an attacker-controlled value can never build a keychain account or
    // on-disk filename.
    for (const bad of ['../etc', 'env_a/000000000000', 'env_a', 'ENV_A-000000000000', '']) {
      await expect(store.setSessionToken('tok', bad)).rejects.toThrow(/Invalid envKey/)
      await expect(store.getSessionToken(bad)).rejects.toThrow(/Invalid envKey/)
      await expect(store.clearSessionToken(bad)).rejects.toThrow(/Invalid envKey/)
    }
    // Nothing was written for any rejected key.
    expect(keychain.size).toBe(0)
  })
})