agent-messenger 2.3.0 → 2.5.0

package/src/platforms/kakaotalk/protocol/session.ts

@@ -7,13 +7,14 @@ import {
   CHECKIN_HOST,
   CHECKIN_PORT,
   COUNTRY_ISO,
+  DTYPE,
   LANG,
   MCCMNC,
   PING_INTERVAL_MS,
   PROTOCOL_VERSION,
 } from './config'
 import { LocoConnection } from './connection'
-import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket } from './types'
+import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket, SyncState } from './types'
 
 export class LocoSession {
   private connection: LocoConnection | null = null
@@ -21,7 +22,7 @@ export class LocoSession {
   private pushHandler: ((packet: LocoPacket) => void) | null = null
   private closeHandler: (() => void) | null = null
 
-  async login(oauthToken: string, userId: string, deviceUuid: string): Promise<LoginListResponse> {
+  async login(oauthToken: string, userId: string, deviceUuid: string, syncState?: SyncState): Promise<LoginListResponse> {
     const { host, port } = await this.bookAndCheckin(userId)
 
     this.connection = new LocoConnection()
@@ -34,20 +35,28 @@ export class LocoSession {
       this.connection.onClose(this.closeHandler)
     }
 
+    const chatIds = syncState?.chatIds.map((id) => new Long(id.low, id.high)) ?? []
+    const maxIds = syncState?.maxIds.map((id) => new Long(id.low, id.high)) ?? []
+    const lastTokenId = syncState
+      ? new Long(syncState.lastTokenId.low, syncState.lastTokenId.high)
+      : Long.fromNumber(0)
+    const lbk = syncState?.lbk ?? 0
+
     const response = await this.connection.sendPacket('LOGINLIST', {
       appVer: APP_VERSION,
       prtVer: PROTOCOL_VERSION,
       os: 'mac',
       lang: LANG,
+      dtype: DTYPE,
       duuid: deviceUuid,
       oauthToken,
       ntype: 0,
       MCCMNC: MCCMNC,
-      revision: 0,
-      chatIds: [],
-      maxIds: [],
-      lastTokenId: Long.fromNumber(0),
-      lbk: Long.fromNumber(0),
+      revision: syncState?.revision ?? 0,
+      chatIds,
+      maxIds,
+      lastTokenId,
+      lbk,
       rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
       bg: false,
     })
@@ -115,6 +124,19 @@ export class LocoSession {
     })
   }
 
+  async getChatLogs(chatIds: Long[], sinces: Long[]): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('MCHATLOGS', {
+      chatIds,
+      sinces,
+    })
+  }
+
+  async getChatInfo(chatId: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('CHATONROOM', { chatId })
+  }
+
   async getChatList(lastTokenId?: Long, lastChatId?: Long): Promise<LocoPacket> {
     if (!this.connection) throw new Error('Not connected')
     return this.connection.sendPacket('LCHATLIST', {

package/src/platforms/kakaotalk/protocol/types.ts

@@ -25,6 +25,15 @@ export interface ChatListResponse {
   [key: string]: unknown
 }
 
+export interface SyncState {
+  version: 2
+  revision: number
+  chatIds: Array<{ low: number; high: number }>
+  maxIds: Array<{ low: number; high: number }>
+  lastTokenId: { low: number; high: number }
+  lbk: number
+}
+
 // LOGINLIST uses short BSON field names: c=chatId, t=type, a=activeMembers, etc.
 export interface LoginListResponse extends ChatListResponse {
   userId: number

package/src/platforms/kakaotalk/types.ts

@@ -125,6 +125,36 @@ export const KakaoSendResultSchema = z.object({
   sent_at: z.number(),
 })
 
+export interface KakaoProfile {
+  user_id: string
+  nickname: string
+  profile_image_url: string | null
+  original_profile_image_url: string | null
+  background_image_url?: string | null
+  original_background_image_url?: string | null
+  fullname?: string | null
+  status_message: string | null
+  account_display_id: string | null
+  account_email?: string | null
+  pstn_number?: string | null
+  email_verified?: boolean | null
+}
+
+export const KakaoProfileSchema = z.object({
+  user_id: z.string(),
+  nickname: z.string(),
+  profile_image_url: z.string().nullable(),
+  original_profile_image_url: z.string().nullable(),
+  background_image_url: z.string().nullable().optional(),
+  original_background_image_url: z.string().nullable().optional(),
+  fullname: z.string().nullable().optional(),
+  status_message: z.string().nullable(),
+  account_display_id: z.string().nullable(),
+  account_email: z.string().nullable().optional(),
+  pstn_number: z.string().nullable().optional(),
+  email_verified: z.boolean().nullable().optional(),
+})
+
 export const KakaoAccountCredentialsSchema = z.object({
   account_id: z.string(),
   oauth_token: z.string(),

package/src/platforms/line/cli.ts

@@ -4,7 +4,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, friendCommand, messageCommand, profileCommand } from './commands/index'
+import { authCommand, chatCommand, friendCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureLineAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -32,7 +32,7 @@ program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(friendCommand)
 program.addCommand(messageCommand)
-program.addCommand(profileCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

package/src/platforms/line/client.ts

@@ -2,34 +2,13 @@ import { mkdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-type LinejsModule = typeof import('@evex/linejs')
-type LinejsStorageModule = typeof import('@evex/linejs/storage')
-type Client = Awaited<ReturnType<LinejsModule['loginWithQR']>>
-
-let cachedLinejs: LinejsModule | undefined
-let cachedLinejsStorage: LinejsStorageModule | undefined
-
-const INSTALL_HINT = '@evex/linejs is required for LINE support. Install it with: bun add @evex/linejs@npm:@jsr/evex__linejs'
-
-async function getLinejs(): Promise<LinejsModule> {
-  if (cachedLinejs) return cachedLinejs
-  try {
-    cachedLinejs = await import('@evex/linejs')
-    return cachedLinejs
-  } catch {
-    throw new Error(INSTALL_HINT)
-  }
-}
-
-async function getLinejsStorage(): Promise<LinejsStorageModule> {
-  if (cachedLinejsStorage) return cachedLinejsStorage
-  try {
-    cachedLinejsStorage = await import('@evex/linejs/storage')
-    return cachedLinejsStorage
-  } catch {
-    throw new Error(INSTALL_HINT)
-  }
-}
+import {
+  loginWithQR as linejsLoginWithQR,
+  loginWithPassword as linejsLoginWithPassword,
+  loginWithAuthToken as linejsLoginWithAuthToken,
+  type Client,
+} from '@evex/linejs'
+import { FileStorage } from '@evex/linejs/storage'
 
 import { LineCredentialManager } from './credential-manager'
 import type {
@@ -61,8 +40,7 @@ function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
 
-async function createStorage(accountId?: string) {
-  const { FileStorage } = await getLinejsStorage()
+function createStorage(accountId?: string): FileStorage {
   const dir = join(homedir(), '.config', 'agent-messenger', 'line-storage')
   mkdirSync(dir, { recursive: true })
   return new FileStorage(join(dir, `${accountId ?? 'default'}.json`))
@@ -82,11 +60,10 @@ export class LineClient {
     onPincode: (pin: string) => void
   }): Promise<LineLoginResult> {
     try {
-      const linejs = await getLinejs()
       const device: LineDevice = options.device ?? getDefaultDevice()
-      const storage = await createStorage()
+      const storage = createStorage()
 
-      const client = await linejs.loginWithQR(
+      const client = await linejsLoginWithQR(
         {
           onReceiveQRUrl: (url) => options.onQRUrl(url),
           onPincodeRequest: (pin) => options.onPincode(pin),
@@ -126,11 +103,10 @@ export class LineClient {
     onPincode: (pin: string) => void
   }): Promise<LineLoginResult> {
     try {
-      const linejs = await getLinejs()
       const device: LineDevice = options.device ?? getDefaultDevice()
-      const storage = await createStorage()
+      const storage = createStorage()
 
-      const client = await linejs.loginWithPassword(
+      const client = await linejsLoginWithPassword(
         {
           email: options.email,
           password: options.password,
@@ -178,11 +154,10 @@ export class LineClient {
         creds = account
       }
 
-      const linejs = await getLinejs()
       const device: LineDevice = creds.device ?? getDefaultDevice()
-      const storage = await createStorage()
+      const storage = createStorage()
 
-      this.client = await linejs.loginWithAuthToken(creds.auth_token, { device, storage })
+      this.client = await linejsLoginWithAuthToken(creds.auth_token, { device, storage })
       return this
     } catch (error) {
       throw wrapError(error, 'login_failed')

package/src/platforms/line/commands/auth.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineCredentialManager } from '../credential-manager'
+import { authCommand } from './auth'
+
+let getAccountSpy: ReturnType<typeof spyOn>
+let listAccountsSpy: ReturnType<typeof spyOn>
+let setCurrentAccountSpy: ReturnType<typeof spyOn>
+let removeAccountSpy: ReturnType<typeof spyOn>
+let clearAllSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  getAccountSpy = spyOn(LineCredentialManager.prototype, 'getAccount').mockResolvedValue({
+    account_id: 'u123',
+    auth_token: 'token-abc',
+    device: 'ANDROIDSECONDARY',
+    display_name: 'Test User',
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  })
+
+  listAccountsSpy = spyOn(LineCredentialManager.prototype, 'listAccounts').mockResolvedValue([
+    {
+      account_id: 'u123',
+      display_name: 'Test User',
+      device: 'ANDROIDSECONDARY',
+      is_current: true,
+      created_at: '2024-01-01T00:00:00Z',
+    },
+    {
+      account_id: 'u456',
+      display_name: 'Other User',
+      device: 'DESKTOPMAC',
+      is_current: false,
+      created_at: '2024-01-02T00:00:00Z',
+    },
+  ])
+
+  setCurrentAccountSpy = spyOn(LineCredentialManager.prototype, 'setCurrentAccount').mockResolvedValue(undefined)
+  removeAccountSpy = spyOn(LineCredentialManager.prototype, 'removeAccount').mockResolvedValue(undefined)
+  clearAllSpy = spyOn(LineCredentialManager.prototype, 'clearAll').mockResolvedValue(undefined)
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  getAccountSpy?.mockRestore()
+  listAccountsSpy?.mockRestore()
+  setCurrentAccountSpy?.mockRestore()
+  removeAccountSpy?.mockRestore()
+  clearAllSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('status: outputs account info when account exists', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'status'])
+
+  // then
+  expect(getAccountSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.account_id).toBe('u123')
+  expect(output.display_name).toBe('Test User')
+  expect(output.device).toBe('ANDROIDSECONDARY')
+})
+
+test('status: outputs error when no account configured', async () => {
+  // given
+  getAccountSpy.mockResolvedValue(null)
+
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'status'])
+
+  // then
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.error).toBe('No LINE account configured')
+})
+
+test('list: outputs all accounts', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'list'])
+
+  // then
+  expect(listAccountsSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].account_id).toBe('u123')
+  expect(output[1].account_id).toBe('u456')
+})
+
+test('list: outputs empty array when no accounts', async () => {
+  // given
+  listAccountsSpy.mockResolvedValue([])
+
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(0)
+})
+
+test('use: sets current account and outputs result', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'use', 'u456'])
+
+  // then
+  expect(setCurrentAccountSpy).toHaveBeenCalledWith('u456')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.current_account).toBe('u456')
+})
+
+test('logout: removes specific account when account-id provided', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'logout', 'u123'])
+
+  // then
+  expect(removeAccountSpy).toHaveBeenCalledWith('u123')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message).toContain('u123')
+})
+
+test('logout: clears all accounts when no account-id provided', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'logout'])
+
+  // then
+  expect(clearAllSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message).toBe('Logged out')
+})

package/src/platforms/line/commands/auth.ts

@@ -1,19 +1,13 @@
-import { execSync } from 'node:child_process'
-import { writeFileSync, unlinkSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
 import { Command } from 'commander'
-import QRCode from 'qrcode'
 
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
+import { displayQR } from '@/shared/utils/qr'
 import { info } from '@/shared/utils/stderr'
 
 import { LineClient } from '../client'
 import { LineCredentialManager } from '../credential-manager'
 import type { LineDevice } from '../types'
-import { LINE_NEXT_ACTIONS } from '../types'
 
 function isInteractiveSession(): boolean {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY)
@@ -23,32 +17,6 @@ function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
 
-async function openQRInBrowser(url: string): Promise<void> {
-  const svgString = await QRCode.toString(url, { type: 'svg', margin: 2 })
-  const html = `<!DOCTYPE html>
-<html><head><meta charset="utf-8"><title>LINE QR Login</title>
-<style>body{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;font-family:-apple-system,system-ui,sans-serif;background:#06C755}
-.card{background:#fff;border-radius:16px;padding:40px;text-align:center;box-shadow:0 4px 24px rgba(0,0,0,.15)}
-h1{margin:0 0 8px;font-size:22px;color:#111}p{margin:0 0 24px;color:#666;font-size:14px}
-svg{width:280px;height:280px}</style></head>
-<body><div class="card"><h1>LINE Login</h1><p>Scan with the LINE mobile app</p>${svgString}</div></body></html>`
-
-  const htmlPath = join(tmpdir(), `line-qr-${Date.now()}.html`)
-  writeFileSync(htmlPath, html)
-
-  try {
-    if (process.platform === 'darwin') {
-      execSync(`open "${htmlPath}"`, { stdio: 'ignore' })
-    } else if (process.platform === 'win32') {
-      execSync(`start "" "${htmlPath}"`, { stdio: 'ignore' })
-    } else {
-      execSync(`xdg-open "${htmlPath}"`, { stdio: 'ignore' })
-    }
-  } catch {}
-
-  setTimeout(() => { try { unlinkSync(htmlPath) } catch {} }, 30_000)
-}
-
 async function loginAction(options: {
   email?: string
   password?: string
@@ -75,18 +43,23 @@ async function loginAction(options: {
       const profile = await client.getProfile()
       const credentials = { ...tempCredentials, account_id: profile.mid, display_name: profile.display_name }
       await credManager.setAccount(credentials)
-      console.log(formatOutput({
-        authenticated: true,
-        account_id: profile.mid,
-        display_name: profile.display_name,
-        device,
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            authenticated: true,
+            account_id: profile.mid,
+            display_name: profile.display_name,
+            device,
+          },
+          options.pretty,
+        ),
+      )
     } else if (options.email && options.password) {
       const result = await client.loginWithEmail({
         email: options.email,
         password: options.password,
         device,
-          onPincode: (pin) => {
+        onPincode: (pin) => {
           if (interactive) {
             info(`\nEnter this PIN in the LINE mobile app: ${pin}\n`)
           }
@@ -94,22 +67,17 @@ async function loginAction(options: {
       })
       console.log(formatOutput(result, options.pretty))
     } else {
-      if (!interactive) {
-        console.log(formatOutput(LINE_NEXT_ACTIONS.run_interactive, options.pretty))
-        return
-      }
-
       const result = await client.loginWithQR({
         device,
         onQRUrl: async (url) => {
-          await openQRInBrowser(url).catch(() => {})
-          try {
-            const qrAscii = await QRCode.toString(url, { type: 'terminal', small: true })
-            info('\nScan this QR code with the LINE mobile app:\n')
-            info(qrAscii)
-          } catch {
-            info(`\nOpen the QR code in the browser window, or scan this URL:\n${url}\n`)
-          }
+          await displayQR(url, {
+            platform: 'LINE',
+            brandColor: '#06C755',
+            scanInstruction: 'Scan with the LINE mobile app',
+            interactive,
+            formatOutput,
+            pretty: options.pretty,
+          })
         },
         onPincode: (pin) => {
           info(`\nEnter this PIN in the LINE mobile app: ${pin}\n`)
@@ -132,13 +100,18 @@ async function statusAction(options: { pretty?: boolean; account?: string }): Pr
       return
     }
 
-    console.log(formatOutput({
-      account_id: account.account_id,
-      device: account.device,
-      display_name: account.display_name,
-      created_at: account.created_at,
-      updated_at: account.updated_at,
-    }, options.pretty))
+    console.log(
+      formatOutput(
+        {
+          account_id: account.account_id,
+          device: account.device,
+          display_name: account.display_name,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+        },
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }
@@ -187,7 +160,10 @@ export const authCommand = new Command('auth')
       .option('--email <email>', 'Email address for email/password login')
       .option('--password <password>', 'Password for email login')
       .option('--token <token>', 'Login with existing auth token directly')
-      .option('--device <type>', 'Device type (default: ANDROIDSECONDARY). Secondary device that coexists with LINE desktop. Use DESKTOPMAC/DESKTOPWIN to replace desktop session.')
+      .option(
+        '--device <type>',
+        'Device type (default: ANDROIDSECONDARY). Secondary device that coexists with LINE desktop. Use DESKTOPMAC/DESKTOPWIN to replace desktop session.',
+      )
       .option('--pretty', 'Pretty print JSON output')
       .action(loginAction),
   )

package/src/platforms/line/commands/chat.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { chatCommand } from './chat'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getChatsSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getChatsSpy = spyOn(LineClient.prototype, 'getChats').mockResolvedValue([
+    {
+      chat_id: 'c111',
+      type: 'user',
+      display_name: 'Alice',
+      member_count: 2,
+    },
+    {
+      chat_id: 'c222',
+      type: 'group',
+      display_name: 'Team Chat',
+      member_count: 10,
+    },
+    {
+      chat_id: 'c333',
+      type: 'room',
+      display_name: 'Project Room',
+      member_count: 5,
+    },
+  ])
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getChatsSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs chats', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 50 })
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(3)
+  expect(output[0].chat_id).toBe('c111')
+  expect(output[1].chat_id).toBe('c222')
+})
+
+test('list: uses default limit of 50 when no limit provided', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 50 })
+})
+
+test('list: uses custom limit when --limit option provided', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list', '--limit', '10'])
+
+  // then
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 10 })
+})
+
+test('list: closes client after fetching chats', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs chat metadata', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const chat = output[0]
+  expect(chat.chat_id).toBeDefined()
+  expect(chat.type).toBeDefined()
+  expect(chat.display_name).toBeDefined()
+})
+
+test('list: includes different chat types', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const types = output.map((c: { type: string }) => c.type)
+  expect(types).toContain('user')
+  expect(types).toContain('group')
+  expect(types).toContain('room')
+})