Skip to content

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

TypeScript
13.8 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import fs from 'node:fs/promises'
import os from 'node:os'
import path from 'node:path'
import { testLoginResult, testSessionMe } from '../../testSupport/authTestFixtures.js'

function pending<T>() {
  let resolve!: (value: T) => void
  let reject!: (error: Error) => void
  const promise = new Promise<T>((done, fail) => {
    resolve = done
    reject = fail
  })
  return { promise, resolve, reject }
}

const originalConfigPath = process.env.CLERUM_DESKTOP_CONFIG_PATH
let directory = ''
let closeStore: (() => void) | undefined

afterEach(async () => {
  closeStore?.()
  vi.restoreAllMocks()
  vi.doUnmock('electron')
  vi.resetModules()
  if (originalConfigPath === undefined) delete process.env.CLERUM_DESKTOP_CONFIG_PATH
  else process.env.CLERUM_DESKTOP_CONFIG_PATH = originalConfigPath
  if (directory) await fs.rm(directory, { recursive: true, force: true })
})

async function fixture() {
  directory = await fs.mkdtemp(path.join(os.tmpdir(), 'evenfire-discovery-lifecycle-'))
  const configPath = path.join(directory, 'runtime.json')
  process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
  vi.resetModules()
  vi.doMock('electron', () => ({
    app: {
      getPath: () => directory,
      isPackaged: false,
      isReady: () => true,
      setName: vi.fn(),
      setPath: vi.fn(),
    },
    safeStorage: { isEncryptionAvailable: () => false },
  }))
  const [{ AppService }, config, { AuthClient }, { RpcProxyClient }, { TokenStore }, chat] =
    await Promise.all([
      import('../appService.js'),
      import('../config.js'),
      import('../authClient.js'),
      import('../rpcProxyClient.js'),
      import('../tokenStore.js'),
      import('../chatStoreBinding.js'),
    ])
  chat.__setChatStoreBaseDirForTests(path.join(directory, 'chats'))
  closeStore = chat.unbindChatStore
  const rest = 'https://api-a.example.test'
  const rpc = 'https://rpc-discovered.example.test'
  await config.saveDesktopRuntimeConfig({ externalRestApiBaseUrl: rest, rpcProxyBaseUrl: '' })
  const store = new TokenStore({ isolatedUserDataPath: directory })
  const service = new AppService()
  ;(service as unknown as { tokenStore: InstanceType<typeof TokenStore> }).tokenStore = store
  const discovery = vi.spyOn(AuthClient.prototype, 'getDesktopEnvironment')
  discovery.mockRejectedValueOnce(new Error('initial discovery unavailable'))
  discovery.mockResolvedValue({ externalRestApiBaseUrl: rest, rpcProxyBaseUrl: rpc, appName: 'A' })
  vi.spyOn(AuthClient.prototype, 'googleLogin').mockResolvedValue(
    testLoginResult('synthetic-session-a', testSessionMe())
  )
  vi.spyOn(AuthClient.prototype, 'health').mockResolvedValue({ status: 'ok' })
  const rpcHealth = vi.spyOn(RpcProxyClient.prototype, 'health').mockResolvedValue({ status: 'ok' })
  return { service, config, configPath, store, chat, rest, rpc, AuthClient, discovery, rpcHealth }
}

describe('RPC discovery lifecycle through native producers', () => {
  it('retires pending A metadata when native setup saves B after a failed team transition', async () => {
    const { service, config, AuthClient, discovery } = await fixture()
    await service.googleLogin('synthetic-google-token')
    await service.getDependenciesHealth()
    vi.spyOn(AuthClient.prototype, 'switchTeam').mockResolvedValue({
      token: 'synthetic-team-b',
      team: { id: 'team-b', name: 'B', role: 'member' },
    })
    vi.spyOn(AuthClient.prototype, 'getMe').mockRejectedValue(
      new Error('fixture team refresh failed')
    )
    await expect(service.switchTeam('team-b')).rejects.toThrow('team refresh failed')
    const { MemberRegistrationServiceClient } =
      await import('../memberRegistrationServiceClient.js')
    const restB = 'https://api-b.example.test'
    vi.spyOn(MemberRegistrationServiceClient.prototype, 'completeDesktopSetup').mockResolvedValue({
      valid: true,
      email: '[email protected]',
      externalRestApiBaseUrl: restB,
      rpcProxyBaseUrl: 'https://rpc-b.example.test',
      appName: 'B',
    } as never)
    discovery.mockRejectedValue(new Error('B discovery unavailable'))
    await service.completeDesktopSetup('[email protected]', 'synthetic-setup-token')
    expect(
      (service as unknown as { pendingRuntimeConfigDiscovery: unknown })
        .pendingRuntimeConfigDiscovery
    ).toBeNull()
    vi.spyOn(AuthClient.prototype, 'googleLogin').mockRejectedValue(
      new Error('fixture B login rejected')
    )
    await expect(service.googleLogin('synthetic-B-google')).rejects.toThrow('B login rejected')
    expect(config.config.externalRestApiBaseUrl).toBe(restB)
    expect(config.config.rpcProxyBaseUrl).toBe('')
  })

  it('retires pending discovery when a durable RPC endpoint is configured on the same profile', async () => {
    const { service, config, rest } = await fixture()
    await service.googleLogin('synthetic-google-token')
    await service.getDependenciesHealth()
    await service.saveRuntimeConfig({
      externalRestApiBaseUrl: rest,
      rpcProxyBaseUrl: 'https://durable-rpc.example.test',
    })
    expect(
      (service as unknown as { pendingRuntimeConfigDiscovery: unknown })
        .pendingRuntimeConfigDiscovery
    ).toBeNull()
    expect(config.config.rpcProxyBaseUrl).toBe('https://durable-rpc.example.test')
    expect(service.getCachedUserId()).toBeNull()
    await service.getDependenciesHealth()
    expect(config.config.rpcProxyBaseUrl).toBe('https://durable-rpc.example.test')
  })

  it('drops discovery for A that settles after native setup has selected B', async () => {
    const { service, config, rest, rpc, discovery } = await fixture()
    await service.googleLogin('synthetic-google-token')
    const response = pending<{
      externalRestApiBaseUrl: string
      rpcProxyBaseUrl: string
      appName: string
    }>()
    const started = pending<void>()
    discovery.mockImplementationOnce(() => {
      started.resolve()
      return response.promise
    })
    const health = service.getDependenciesHealth()
    await started.promise
    await service.logout()
    const { MemberRegistrationServiceClient } =
      await import('../memberRegistrationServiceClient.js')
    const restB = 'https://api-b.example.test'
    vi.spyOn(MemberRegistrationServiceClient.prototype, 'completeDesktopSetup').mockResolvedValue({
      valid: true,
      email: '[email protected]',
      externalRestApiBaseUrl: restB,
      rpcProxyBaseUrl: 'https://rpc-b.example.test',
      appName: 'B',
    } as never)
    discovery.mockRejectedValue(new Error('B discovery unavailable'))
    await service.completeDesktopSetup('[email protected]', 'synthetic-setup-token')
    const bindingB = config.getActiveEnvKey()
    response.resolve({ externalRestApiBaseUrl: rest, rpcProxyBaseUrl: rpc, appName: 'A' })
    await health
    expect(config.config.externalRestApiBaseUrl).toBe(restB)
    expect(config.getActiveEnvKey()).toBe(bindingB)
    expect(config.config.rpcProxyBaseUrl).toBe('')
    await service.getDependenciesHealth()
    expect(config.config.externalRestApiBaseUrl).toBe(restB)
  })

  it('commits restore-held discovery before a newer interactive login captures identity', async () => {
    const { service, config, store, discovery, AuthClient, rpc } = await fixture()
    const key = config.getActiveEnvKey()
    await store.setSessionToken('synthetic-saved-session', key)
    const me = pending<ReturnType<typeof testSessionMe>>()
    const started = pending<void>()
    vi.spyOn(AuthClient.prototype, 'getMe').mockImplementation(() => {
      started.resolve()
      return me.promise
    })
    const restore = service.getSessionState()
    await started.promise
    await service.getDependenciesHealth()
    expect(config.config.rpcProxyBaseUrl).toBe('')
    discovery.mockRejectedValue(new Error('subsequent discovery unavailable'))
    await service.googleLogin('synthetic-interactive-token')
    const nextKey = config.getActiveEnvKey()
    expect(nextKey).not.toBe(key)
    expect(config.config.rpcProxyBaseUrl).toBe(rpc)
    expect(await store.getSessionToken(nextKey)).toBe('synthetic-session-a')
    me.resolve(testSessionMe({ id: 'restore-user' }))
    await expect(restore).resolves.toMatchObject({ authenticated: true, me: { id: 'user-a' } })
    expect(service.getCachedUserId()).toBe('user-a')
  })

  it.each(['Google', 'password'])(
    'persists pending discovery only in failed %s login cleanup',
    async kind => {
      const { service, config, store, discovery, AuthClient, configPath, rpc } = await fixture()
      await store.setSessionToken('synthetic-saved-session', config.getActiveEnvKey())
      const me = pending<ReturnType<typeof testSessionMe>>()
      const started = pending<void>()
      vi.spyOn(AuthClient.prototype, 'getMe').mockImplementation(() => {
        started.resolve()
        return me.promise
      })
      const restore = service.getSessionState()
      await started.promise
      await service.getDependenciesHealth()
      const write = fs.writeFile.bind(fs)
      let rejected = false
      vi.spyOn(fs, 'writeFile').mockImplementation(async (file, ...args) => {
        if (String(file) === configPath && !rejected) {
          rejected = true
          throw new Error('fixture prelogin persistence denied')
        }
        return write(file, ...args)
      })
      discovery.mockRejectedValue(new Error('subsequent discovery unavailable'))
      const loginResponse = pending<ReturnType<typeof testLoginResult>>()
      const loginStarted = pending<void>()
      const dispatchLogin = () => {
        loginStarted.resolve()
        return loginResponse.promise
      }
      vi.spyOn(AuthClient.prototype, 'googleLogin').mockImplementation(dispatchLogin)
      vi.spyOn(AuthClient.prototype, 'passwordLogin').mockImplementation(dispatchLogin)
      const login =
        kind === 'Google'
          ? service.googleLogin('synthetic-google')
          : service.passwordLogin('[email protected]', 'fixture-password')
      const result = login.catch(error => error as Error)
      await loginStarted.promise
      me.resolve(testSessionMe())
      await restore
      expect(config.config.rpcProxyBaseUrl).toBe('')
      loginResponse.reject(new Error('fixture login rejected'))
      expect(await result).toMatchObject({ message: 'fixture login rejected' })
      expect(rejected).toBe(true)
      expect(config.config.rpcProxyBaseUrl).toBe(rpc)
      expect(JSON.parse(await fs.readFile(configPath, 'utf8')).rpcProxyBaseUrl).toBe(rpc)
      expect(service.getCachedUserId()).toBeNull()
    }
  )

  it('retries discovery persistence after logout ends auth but its config write fails', async () => {
    const { service, config, configPath, store, rest, rpc, discovery, chat } = await fixture()
    await service.googleLogin('synthetic-google-token')
    await chat.requireChatStore().createChat('agent-a', 'chat-a')
    const oldKey = config.getActiveEnvKey()
    await service.getDependenciesHealth()
    const write = fs.writeFile.bind(fs)
    const failure = vi.spyOn(fs, 'writeFile').mockImplementation(async (file, ...args) => {
      if (String(file) === configPath) throw new Error('fixture config write denied')
      return write(file, ...args)
    })
    await service.logout()
    failure.mockRestore()
    expect(service.getCachedUserId()).toBeNull()
    expect(await store.getSessionToken(oldKey)).toBeNull()
    await service.getDependenciesHealth()
    await service.getDependenciesHealth()
    expect(config.config.externalRestApiBaseUrl).toBe(rest)
    expect(config.config.rpcProxyBaseUrl).toBe(rpc)
    expect(JSON.parse(await fs.readFile(configPath, 'utf8')).rpcProxyBaseUrl).toBe(rpc)
    expect(discovery).toHaveBeenCalledTimes(3)
  })

  it('recovers discovery after a team switch clears its partially replaced session', async () => {
    const { service, config, store, rpc, AuthClient, discovery } = await fixture()
    await service.googleLogin('synthetic-google-token')
    const oldKey = config.getActiveEnvKey()
    await service.getDependenciesHealth()
    vi.spyOn(AuthClient.prototype, 'switchTeam').mockResolvedValue({
      token: 'synthetic-team-b',
      team: { id: 'team-b', name: 'B', role: 'member' },
    })
    vi.spyOn(AuthClient.prototype, 'getMe').mockRejectedValue(
      new Error('fixture team refresh failed')
    )
    await expect(service.switchTeam('team-b')).rejects.toThrow('team refresh failed')
    expect(service.getCachedUserId()).toBeNull()
    expect(await store.getSessionToken(oldKey)).toBeNull()
    await service.getDependenciesHealth()
    expect(config.config.rpcProxyBaseUrl).toBe(rpc)
    expect(discovery).toHaveBeenCalledTimes(3)
  })

  it.each(['javascript:alert(1)', 'file:///fixture', undefined, '', 42])(
    'rejects invalid discovered RPC %s and permits a later valid discovery',
    async invalid => {
      const { service, config, rpc, rest, store, discovery, rpcHealth } = await fixture()
      await service.googleLogin('synthetic-google-token')
      const key = config.getActiveEnvKey()
      discovery.mockResolvedValueOnce({
        externalRestApiBaseUrl: rest,
        rpcProxyBaseUrl: invalid,
        appName: 'A',
      } as never)
      const activeGeneration = service.getSessionGeneration()
      await service.getDependenciesHealth()
      expect(config.config.rpcProxyBaseUrl).toBe('')
      await service.getDependenciesHealth()
      expect(discovery).toHaveBeenCalledTimes(3)
      expect(config.getActiveEnvKey()).toBe(key)
      expect(service.getSessionGeneration()).toBe(activeGeneration)
      expect(await store.getSessionToken(key)).toBe('synthetic-session-a')
      expect(service.getCachedUserId()).toBe('user-a')
      // The real transport provider must now supply the recovered endpoint.
      rpcHealth.mockRestore()
      const fetch = vi
        .spyOn(globalThis, 'fetch')
        .mockResolvedValue(new Response(JSON.stringify({ status: 'ok' }), { status: 200 }))
      await service.getDependenciesHealth()
      expect(fetch).toHaveBeenCalledWith(`${rpc}/health`, expect.any(Object))
    }
  )
})