Skip to content

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

TypeScript
21.8 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import {
  cleanupNativeCommitTestHarness,
  createNativeCommitTestHarness,
  deferred,
} from '../../testSupport/appService.nativeCommitTestHarness.js'
import {
  testLoginResult,
  testSessionMe,
  testTeamSwitchResult,
} from '../../testSupport/authTestFixtures.js'

afterEach(async () => {
  vi.useRealTimers()
  await cleanupNativeCommitTestHarness()
})

describe('AppService deliberate team transition ownership', () => {
  it('returns a committed same-team approval before a queued logout', async () => {
    const { service } = await createNativeCommitTestHarness()
    const decisionResponse = deferred<{ approvalId: string; status: string }>()
    const decisionStarted = deferred<void>()
    const logoutCleanupStarted = vi.fn()
    const me = testSessionMe()
    const app = service as unknown as {
      authClient: unknown
      decideWorkflowApproval(
        approvalId: string,
        decision: 'approve' | 'reject',
        note?: string,
        options?: { teamId?: string | null }
      ): Promise<{ approvalId: string; status: string }>
      suspendDesktopGfsUploadsForAuthBoundary: () => Promise<void>
    }
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult('synthetic-session-a', me)),
      decideWorkflowApproval: vi.fn(() => {
        decisionStarted.resolve()
        return decisionResponse.promise
      }),
    }
    app.suspendDesktopGfsUploadsForAuthBoundary = vi.fn(async () => {
      logoutCleanupStarted()
    })
    await service.googleLogin('synthetic-google-token')

    const decision = app.decideWorkflowApproval('approval-a', 'approve', undefined, {
      teamId: 'team-a',
    })
    await decisionStarted.promise
    const logout = service.logout()
    await new Promise(resolve => setTimeout(resolve, 0))
    expect(logoutCleanupStarted).not.toHaveBeenCalled()

    const committedResponse = { approvalId: 'approval-a', status: 'approved' }
    decisionResponse.resolve(committedResponse)
    await expect(decision).resolves.toEqual(committedResponse)
    await expect(logout).resolves.toBeTypeOf('number')
  })

  it('keeps a saved-session restore when RPC discovery completes before getMe', async () => {
    const { service, runtimeConfig, restA } = await createNativeCommitTestHarness()
    await runtimeConfig.saveDesktopRuntimeConfig({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: '',
      appName: 'Environment A',
    })
    const discovery = deferred<{
      externalRestApiBaseUrl: string
      rpcProxyBaseUrl: string
      appName: string
    }>()
    const discoveryStarted = deferred<void>()
    const getMeResponse = deferred<ReturnType<typeof testSessionMe>>()
    const getMeStarted = deferred<void>()
    const me = testSessionMe()
    const app = service as unknown as {
      authClient: unknown
      rpcClient: unknown
      tokenStore: { getSessionToken: ReturnType<typeof vi.fn> }
      getDependenciesHealth(): Promise<unknown>
    }
    app.tokenStore.getSessionToken.mockResolvedValue('saved-session-a')
    const getMe = vi.fn(() => {
      getMeStarted.resolve()
      return getMeResponse.promise
    })
    const getDesktopEnvironment = vi.fn(() => {
      discoveryStarted.resolve()
      return discovery.promise
    })
    app.authClient = {
      getDesktopEnvironment,
      getMe,
      health: vi.fn().mockResolvedValue({ status: 'ok' }),
    }
    app.rpcClient = { health: vi.fn().mockResolvedValue({ status: 'ok' }) }

    const healthRequest = app.getDependenciesHealth()
    await discoveryStarted.promise
    const restore = service.getSessionState()
    await new Promise(resolve => setTimeout(resolve, 0))
    expect(getMe).not.toHaveBeenCalled()
    discovery.resolve({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: 'https://rpc-discovered.example.test',
      appName: 'Environment A',
    })
    await healthRequest
    await getMeStarted.promise
    getMeResponse.resolve(me)

    await expect(restore).resolves.toEqual({ authenticated: true, me })
  })

  it('accepts Google login when RPC discovery enriches its captured REST profile', async () => {
    const { service, runtimeConfig, restA } = await createNativeCommitTestHarness()
    await runtimeConfig.saveDesktopRuntimeConfig({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: '',
      appName: 'Environment A',
    })
    const discovery = deferred<{
      externalRestApiBaseUrl: string
      rpcProxyBaseUrl: string
      appName: string
    }>()
    const discoveryStarted = deferred<void>()
    const getDesktopEnvironment = vi.fn(() => {
      discoveryStarted.resolve()
      return discovery.promise
    })
    const loginResponse = deferred<ReturnType<typeof testLoginResult>>()
    const loginStarted = deferred<void>()
    const me = testSessionMe()
    const app = service as unknown as {
      authClient: unknown
      rpcClient: unknown
      getDependenciesHealth(): Promise<unknown>
    }
    const googleLogin = vi.fn(() => {
      loginStarted.resolve()
      return loginResponse.promise
    })
    app.authClient = {
      getDesktopEnvironment,
      googleLogin,
      health: vi.fn().mockResolvedValue({ status: 'ok' }),
    }
    app.rpcClient = { health: vi.fn().mockResolvedValue({ status: 'ok' }) }

    const login = service.googleLogin('synthetic-google-token')
    const healthRequest = app.getDependenciesHealth()
    await discoveryStarted.promise
    await new Promise(resolve => setTimeout(resolve, 0))
    expect(googleLogin).not.toHaveBeenCalled()
    discovery.resolve({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: 'https://rpc-discovered.example.test',
      appName: 'Environment A',
    })
    await healthRequest
    await loginStarted.promise
    loginResponse.resolve(testLoginResult('synthetic-session-a', me))

    await expect(login).resolves.toEqual({ authenticated: true, me })
  })

  it('persists RPC discovery after a saved-session restore advances the generation', async () => {
    const { service, runtimeConfig, restA } = await createNativeCommitTestHarness()
    const discovery = deferred<{
      externalRestApiBaseUrl: string
      rpcProxyBaseUrl: string
      appName: string
    }>()
    const discoveryStarted = deferred<void>()
    const me = testSessionMe()
    const app = service as unknown as {
      authClient: unknown
      rpcClient: unknown
      tokenStore: { getSessionToken: ReturnType<typeof vi.fn> }
      getDependenciesHealth(): Promise<unknown>
      saveRuntimeConfig(config: {
        externalRestApiBaseUrl: string
        rpcProxyBaseUrl: string
        appName: string
      }): Promise<unknown>
    }
    app.tokenStore.getSessionToken.mockResolvedValue('saved-session-a')
    const getMe = vi.fn().mockResolvedValue(me)
    const getDesktopEnvironment = vi.fn(() => {
      discoveryStarted.resolve()
      return discovery.promise
    })
    app.authClient = {
      getDesktopEnvironment,
      getMe,
      health: vi.fn().mockResolvedValue({ status: 'ok' }),
    }
    app.rpcClient = { health: vi.fn().mockResolvedValue({ status: 'ok' }) }

    const save = app.saveRuntimeConfig({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: '',
      appName: 'Environment A',
    })
    await discoveryStarted.promise
    const restore = service.getSessionState()
    await new Promise(resolve => setTimeout(resolve, 0))
    expect(getMe).not.toHaveBeenCalled()
    discovery.resolve({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: 'https://rpc-discovered.example.test',
      appName: 'Environment A',
    })
    await save
    await expect(restore).resolves.toEqual({ authenticated: true, me })
    expect(getDesktopEnvironment).toHaveBeenCalledOnce()

    expect(runtimeConfig.getDesktopRuntimeConfigState().currentConfig.rpcProxyBaseUrl).toBe(
      'https://rpc-discovered.example.test'
    )
  })

  it('keeps the public session generation stable through transient team hops', async () => {
    const { service } = await createNativeCommitTestHarness()
    const workflowResponse = deferred<{ workflow: string }>()
    const workflowStarted = deferred<void>()
    const meA = testSessionMe()
    const meB = testSessionMe({ teamId: 'team-b', teamName: 'Team B' })
    const app = service as unknown as {
      authClient: unknown
      rpcClient: unknown
      rpcTokenManager: unknown
      readWorkflow(ns: string, name: string): Promise<unknown>
      workflowTeamByKey: Map<string, string>
      workflowKey(ns: string, name: string): string
      getSessionGeneration(): number
    }
    let currentTeamId = 'team-a'
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult('synthetic-session-a', meA)),
      switchTeam: vi.fn(async (_token: string, teamId: string) => {
        currentTeamId = teamId
        return testTeamSwitchResult(teamId)
      }),
      getMe: vi.fn(async () => (currentTeamId === 'team-a' ? meA : meB)),
      readWorkflow: vi.fn(() => {
        workflowStarted.resolve()
        return workflowResponse.promise
      }),
    }
    const prewarmHost = vi
      .fn()
      .mockResolvedValueOnce({ status: 'wake-requested' })
      .mockResolvedValueOnce({ status: 'active' })
    app.rpcClient = { prewarmHost }
    app.rpcTokenManager = {
      clear: vi.fn(),
      getOrIssue: vi.fn().mockResolvedValue({ token: 'synthetic-rpc-token' }),
    }
    await service.googleLogin('synthetic-google-token')
    app.workflowTeamByKey.set(app.workflowKey('team-a', 'flow-a'), 'team-b')
    const sessionGeneration = app.getSessionGeneration()
    vi.useFakeTimers()

    await expect(service.prewarmHost('chatllm')).resolves.toEqual({
      requested: true,
      status: 'wake-requested',
    })
    const workflowRead = app.readWorkflow('team-a', 'flow-a')
    await workflowStarted.promise
    await vi.advanceTimersByTimeAsync(10_000)
    expect(prewarmHost).toHaveBeenCalledTimes(2)

    workflowResponse.resolve({ workflow: 'result' })
    await expect(workflowRead).resolves.toEqual({ workflow: 'result' })

    expect(app.getSessionGeneration()).toBe(sessionGeneration)
    await expect(service.prewarmHost('chatllm')).resolves.toEqual({
      requested: false,
      skipped: 'cooldown',
    })
    expect(prewarmHost).toHaveBeenCalledTimes(2)
  })

  it('advances session generation when a failed restore leaves the borrowed team active', async () => {
    const { service } = await createNativeCommitTestHarness()
    const meA = testSessionMe()
    const meB = testSessionMe({ teamId: 'team-b', teamName: 'Team B' })
    const app = service as unknown as {
      authClient: unknown
      me: { teamId: string } | null
      sessionToken: string | null
      readWorkflow(ns: string, name: string): Promise<unknown>
      workflowTeamByKey: Map<string, string>
      workflowKey(ns: string, name: string): string
      getSessionGeneration(): number
    }
    let currentTeamId = 'team-a'
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult('synthetic-session-a', meA)),
      switchTeam: vi.fn(async (_token: string, teamId: string) => {
        if (teamId === 'team-a' && currentTeamId === 'team-b') {
          throw new Error('restore rejected')
        }
        currentTeamId = teamId
        return testTeamSwitchResult(teamId)
      }),
      getMe: vi.fn(async () => (currentTeamId === 'team-a' ? meA : meB)),
      readWorkflow: vi.fn().mockResolvedValue({ workflow: 'result' }),
    }
    await service.googleLogin('synthetic-google-token')
    app.workflowTeamByKey.set(app.workflowKey('team-a', 'flow-a'), 'team-b')
    const previousGeneration = app.getSessionGeneration()

    await expect(app.readWorkflow('team-a', 'flow-a')).rejects.toThrow('restore rejected')

    expect(app.me?.teamId).toBe('team-b')
    expect(app.sessionToken).toBe('session-team-b')
    expect(app.getSessionGeneration()).toBe(previousGeneration + 1)
  })

  it.each(['Google', 'password'])(
    '%s login continues when optional RPC discovery fails',
    async loginMethod => {
      const { service, runtimeConfig, restA } = await createNativeCommitTestHarness()
      await runtimeConfig.saveDesktopRuntimeConfig({
        externalRestApiBaseUrl: restA,
        rpcProxyBaseUrl: '',
        appName: 'Environment A',
      })
      const me = testSessionMe()
      const getDesktopEnvironment = vi
        .fn()
        .mockRejectedValue(new Error('RPC discovery unavailable'))
      const googleLogin = vi.fn().mockResolvedValue(testLoginResult('google-session-a', me))
      const passwordLogin = vi.fn().mockResolvedValue(testLoginResult('password-session-a', me))
      const app = service as unknown as { authClient: unknown }
      app.authClient = { getDesktopEnvironment, googleLogin, passwordLogin }

      const result =
        loginMethod === 'Google'
          ? await service.googleLogin('synthetic-google-token')
          : await service.passwordLogin('[email protected]', 'synthetic-password')

      expect(result).toMatchObject({ authenticated: true, me })
      expect(getDesktopEnvironment).toHaveBeenCalledOnce()
      if (loginMethod === 'Google') {
        expect(googleLogin).toHaveBeenCalledWith('synthetic-google-token')
        expect(passwordLogin).not.toHaveBeenCalled()
      } else {
        expect(passwordLogin).toHaveBeenCalledWith('[email protected]', 'synthetic-password')
        expect(googleLogin).not.toHaveBeenCalled()
      }
    }
  )

  it('rejects a stale handoff generation after a public login advances the session', async () => {
    const { service, runtimeConfig, optionA } = await createNativeCommitTestHarness()
    const app = service as unknown as {
      authClient: unknown
      selectRuntimeConfigForHandoff(optionId: string, generation: number): Promise<unknown>
    }
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult('fixture-session-a')),
    }
    const previousGeneration = service.getSessionGeneration()
    await service.googleLogin('synthetic-google-token')

    await expect(app.selectRuntimeConfigForHandoff(optionA.id, previousGeneration)).rejects.toThrow(
      'stale_session_generation'
    )
    expect(runtimeConfig.getDesktopRuntimeConfigState().activeOptionId).toBe(optionA.id)
  })

  it('keeps REST discovery for the same profile when logout advances session generation', async () => {
    const { service, runtimeConfig, restA } = await createNativeCommitTestHarness()
    const discovery = deferred<{
      externalRestApiBaseUrl: string
      rpcProxyBaseUrl: string
      appName: string
    }>()
    const discoveryStarted = deferred<void>()
    const getDesktopEnvironment = vi.fn(() => {
      discoveryStarted.resolve()
      return discovery.promise
    })
    const app = service as unknown as {
      sessionToken: string | null
      me: { id: string; email: string; name: string; picture: null; teamId: string; role: string }
      authClient: unknown
      rpcClient: unknown
      suspendDesktopGfsUploadsForAuthBoundary: () => Promise<void>
      getDependenciesHealth(): Promise<unknown>
    }
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult()),
      getDesktopEnvironment,
      health: vi.fn().mockResolvedValue({ status: 'ok' }),
    }
    app.rpcClient = { health: vi.fn().mockResolvedValue({ status: 'ok' }) }
    await service.googleLogin('synthetic-google-token')
    await runtimeConfig.saveDesktopRuntimeConfig({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: '',
      appName: 'Environment A',
    })
    app.suspendDesktopGfsUploadsForAuthBoundary = vi.fn().mockResolvedValue(undefined)

    const healthRequest = app.getDependenciesHealth()
    await discoveryStarted.promise
    await expect(service.logout()).resolves.toBeTypeOf('number')
    discovery.resolve({
      externalRestApiBaseUrl: restA,
      rpcProxyBaseUrl: 'https://rpc-discovered.example.test',
      appName: 'Environment A',
    })
    await healthRequest

    expect(app.sessionToken).toBeNull()
    expect(runtimeConfig.getDesktopRuntimeConfigState().currentConfig.rpcProxyBaseUrl).toBe(
      'https://rpc-discovered.example.test'
    )
  })

  it('lets logout commit while a same-team request is pending and rejects its stale result', async () => {
    const { service } = await createNativeCommitTestHarness()
    const request = deferred<string>()
    const requestStarted = deferred<void>()
    const app = service as unknown as {
      sessionToken: string | null
      me: {
        id: string
        email: string
        name: string
        picture: null
        teamId: string
        teamName: string
        role: string
      } | null
      runWithTeamContext<T>(teamId: string, operation: (token: string) => Promise<T>): Promise<T>
      suspendDesktopGfsUploadsForAuthBoundary: () => Promise<void>
    }
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult()),
    }
    await service.googleLogin('synthetic-google-token')
    app.suspendDesktopGfsUploadsForAuthBoundary = vi.fn().mockResolvedValue(undefined)
    const operation = app.runWithTeamContext('team-a', async () => {
      requestStarted.resolve()
      return request.promise
    })
    await requestStarted.promise

    await expect(service.logout()).resolves.toBeTypeOf('number')
    request.resolve('old-session-result')

    await expect(operation).rejects.toThrow(/stale_(auth_epoch|session_generation)/)
    expect(app.sessionToken).toBeNull()
  })

  it('lets logout commit during teamless session scope discovery', async () => {
    const { service } = await createNativeCommitTestHarness()
    const meResponse = deferred<ReturnType<typeof testSessionMe>>()
    const discoveryStarted = deferred<void>()
    const logoutStarted = deferred<void>()
    const app = service as unknown as {
      sessionToken: string | null
      me: {
        id: string
        email: string
        name: string
        picture: null
        teamId: string | null
        teamName: string | null
        role: string
      } | null
      authClient: unknown
      runWithTeamContext<T>(teamId: string, operation: (token: string) => Promise<T>): Promise<T>
      suspendDesktopGfsUploadsForAuthBoundary: () => Promise<void>
    }
    app.authClient = {
      googleLogin: vi.fn().mockResolvedValue(
        testLoginResult(
          'synthetic-session-a',
          testSessionMe({
            teamId: null,
            teamName: null,
          })
        )
      ),
      getMe: vi.fn(() => {
        discoveryStarted.resolve()
        return meResponse.promise
      }),
    }
    await service.googleLogin('synthetic-google-token')
    app.suspendDesktopGfsUploadsForAuthBoundary = vi.fn(async () => logoutStarted.resolve())
    const operation = vi.fn(async () => 'team result')
    const contextRequest = app.runWithTeamContext('team-a', operation)
    await discoveryStarted.promise

    const logout = service.logout()
    const logoutWasResponsive = await Promise.race([
      logoutStarted.promise.then(() => true),
      new Promise<boolean>(resolve => setTimeout(() => resolve(false), 50)),
    ])
    meResponse.resolve(testSessionMe())

    await expect(contextRequest).rejects.toThrow(/stale_(auth_epoch|session_generation)/)
    await expect(logout).resolves.toBeTypeOf('number')
    expect(logoutWasResponsive).toBe(true)
    expect(operation).not.toHaveBeenCalled()
    expect(app.sessionToken).toBeNull()
  })

  it('finishes GFS activation before a queued workflow read borrows another team', async () => {
    const { service, restA } = await createNativeCommitTestHarness()
    const teamBResponse = deferred<ReturnType<typeof testTeamSwitchResult>>()
    const switchStarted = deferred<void>()
    const tokenTeams = new Map<string, string>([['synthetic-session-a', 'team-a']])
    let issuedToken = 0
    const user = testSessionMe()
    const authClient = {
      googleLogin: vi.fn().mockResolvedValue(testLoginResult('synthetic-session-a', user)),
      switchTeam: vi.fn(async (_token: string, teamId: string) => {
        if (teamId === 'team-b') {
          switchStarted.resolve()
          const response = await teamBResponse.promise
          tokenTeams.set(response.token, teamId)
          return response
        }
        const token = `synthetic-${teamId}-${++issuedToken}`
        tokenTeams.set(token, teamId)
        return testTeamSwitchResult(teamId, token)
      }),
      getMe: vi.fn(async (token: string) => {
        const teamId = tokenTeams.get(token) || 'team-a'
        return { ...user, teamId, teamName: teamId === 'team-b' ? 'Team B' : 'Team A' }
      }),
      readWorkflow: vi.fn(async (token: string) => ({ token })),
    }
    const app = service as unknown as {
      authClient: typeof authClient
      googleLogin: (token: string) => Promise<unknown>
      switchTeam: (teamId: string) => Promise<unknown>
      readWorkflow: (namespace: string, name: string) => Promise<unknown>
      workflowKey: (namespace: string, name: string) => string
      workflowTeamByKey: Map<string, string>
      me: { teamId: string } | null
      gfsScopeIdentity: { teamId: string | null; baseUrl: string } | null
      gfsDispatchBlocked: boolean
      gfsTransientTeamHopDepth: number
    }
    app.authClient = authClient
    await app.googleLogin('synthetic-google-token')
    app.workflowTeamByKey.set(app.workflowKey('workflows', 'approval'), 'team-a')

    const switching = app.switchTeam('team-b')
    await switchStarted.promise
    const workflowRead = app.readWorkflow('workflows', 'approval')
    teamBResponse.resolve(testTeamSwitchResult('team-b', 'synthetic-session-b'))

    const [switchResult, workflowResult] = await Promise.all([switching, workflowRead])

    expect(switchResult).toMatchObject({ authenticated: true, me: { teamId: 'team-b' } })
    expect(tokenTeams.get(authClient.readWorkflow.mock.calls[0][0])).toBe('team-a')
    expect(workflowResult).toMatchObject({ token: expect.any(String) })
    expect(app.me?.teamId).toBe('team-b')
    expect(app.gfsScopeIdentity).toMatchObject({ teamId: 'team-b', baseUrl: restA })
    expect(app.gfsDispatchBlocked).toBe(false)
    expect(app.gfsTransientTeamHopDepth).toBe(0)
  })
})