agent-messenger 2.3.0 → 2.5.0

package/src/platforms/kakaotalk/client.test.ts

@@ -5,6 +5,8 @@ import { KakaoTalkClient, KakaoTalkError } from './client'
 // Mock LocoSession at module level
 const mockLogin = mock(() => Promise.resolve({}))
 const mockGetChatList = mock(() => Promise.resolve({}))
+const mockGetChatLogs = mock(() => Promise.resolve({}))
+const mockGetChatInfo = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
@@ -14,6 +16,8 @@ mock.module('./protocol/session', () => ({
   LocoSession: class MockLocoSession {
     login = mockLogin
     getChatList = mockGetChatList
+    getChatLogs = mockGetChatLogs
+    getChatInfo = mockGetChatInfo
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
     close = mockClose
@@ -28,6 +32,8 @@ function makeLong(n: number): { low: number; high: number } {
 function resetAllMocks() {
   mockLogin.mockReset()
   mockGetChatList.mockReset()
+  mockGetChatLogs.mockReset()
+  mockGetChatInfo.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
   mockClose.mockReset()
@@ -67,6 +73,8 @@ describe('KakaoTalkClient', () => {
   beforeEach(() => {
     resetAllMocks()
     mockLogin.mockResolvedValue(DEFAULT_LOGIN_RESULT)
+    mockGetChatLogs.mockResolvedValue({ body: { status: 0, chatLogs: [], eof: true } })
+    mockGetChatInfo.mockResolvedValue({ body: { l: makeLong(99999) } })
   })
 
   afterEach(() => {
@@ -146,6 +154,68 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    test('falls back to LCHATLIST when login snapshot is empty (new device)', async () => {
+      // given — LOGINLIST returns empty chatDatas with eof:true (new device scenario)
+      const emptyLoginResult = {
+        chatDatas: [],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(emptyLoginResult)
+
+      mockGetChatList.mockResolvedValueOnce({
+        body: {
+          chatDatas: [
+            {
+              c: 100,
+              t: 1,
+              k: ['Alice', 'Bob'],
+              a: 2,
+              n: 3,
+              o: 1700000000,
+              l: { authorId: 1, message: 'hi', sendAt: 1700000000 },
+              ll: makeLong(999),
+            },
+            {
+              c: 200,
+              t: 2,
+              k: ['Charlie'],
+              a: 1,
+              n: 0,
+              o: 1699999000,
+              l: null,
+              ll: makeLong(500),
+            },
+          ],
+          lastTokenId: makeLong(1),
+          lastChatId: makeLong(200),
+          eof: true,
+        },
+      })
+
+      // when — default chat list (no --all flag)
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats()
+
+      // then — fetched via LCHATLIST despite eof:true and no --all
+      expect(chats).toHaveLength(2)
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+      expect(chats[0].display_name).toBe('Alice, Bob')
+      expect(chats[1].display_name).toBe('Charlie')
+
+      client.close()
+    })
+
+    test('does not call LCHATLIST when login snapshot has chats', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      await client.getChats()
+
+      expect(mockGetChatList).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
     test('paginates when all=true and not eof', async () => {
       const loginResult = {
         ...DEFAULT_LOGIN_RESULT,
@@ -254,13 +324,14 @@ describe('KakaoTalkClient', () => {
 
   describe('getMessages', () => {
     test('returns formatted messages', async () => {
-      mockSyncMessages.mockResolvedValueOnce({
+      mockGetChatLogs.mockResolvedValueOnce({
         body: {
+          status: 0,
           chatLogs: [
-            { logId: makeLong(10), type: 1, authorId: 42, message: 'hello', sendAt: 1700000001 },
-            { logId: makeLong(11), type: 1, authorId: 43, message: 'world', sendAt: 1700000002 },
+            { logId: makeLong(10), chatId: 100, type: 1, authorId: 42, message: 'hello', sendAt: 1700000001 },
+            { logId: makeLong(11), chatId: 100, type: 1, authorId: 43, message: 'world', sendAt: 1700000002 },
           ],
-          isOK: true,
+          eof: true,
         },
       })
 
@@ -289,14 +360,15 @@ describe('KakaoTalkClient', () => {
     test('respects count option', async () => {
       const logs = Array.from({ length: 50 }, (_, i) => ({
         logId: makeLong(i + 1),
+        chatId: 100,
         type: 1,
         authorId: 1,
         message: `msg-${i}`,
         sendAt: 1700000000 + i,
       }))
 
-      mockSyncMessages.mockResolvedValueOnce({
-        body: { chatLogs: logs, isOK: true },
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: logs, eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -311,13 +383,14 @@ describe('KakaoTalkClient', () => {
     })
 
     test('sorts messages by sent_at ascending', async () => {
-      mockSyncMessages.mockResolvedValueOnce({
+      mockGetChatLogs.mockResolvedValueOnce({
         body: {
+          status: 0,
           chatLogs: [
-            { logId: makeLong(2), type: 1, authorId: 1, message: 'second', sendAt: 200 },
-            { logId: makeLong(1), type: 1, authorId: 1, message: 'first', sendAt: 100 },
+            { logId: makeLong(2), chatId: 100, type: 1, authorId: 1, message: 'second', sendAt: 200 },
+            { logId: makeLong(1), chatId: 100, type: 1, authorId: 1, message: 'first', sendAt: 100 },
           ],
-          isOK: true,
+          eof: true,
         },
       })
 
@@ -384,6 +457,101 @@ describe('KakaoTalkClient', () => {
     })
   })
 
+  describe('getProfile', () => {
+    const mockFetch = mock(() => Promise.resolve(new Response()))
+
+    beforeEach(() => {
+      mockFetch.mockReset()
+      globalThis.fetch = mockFetch as unknown as typeof fetch
+    })
+
+    afterEach(() => {
+      mockFetch.mockReset()
+    })
+
+    function makeJsonResponse(data: unknown, status = 200): Response {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    test('returns profile data on success', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({
+          profile: {
+            nickName: 'Test User',
+            profileImageUrl: 'https://example.com/profile.jpg',
+            originalProfileImageUrl: 'https://example.com/original.jpg',
+            statusMessage: 'Hello world',
+          },
+        }))
+        .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: 'testuser123' }))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const profile = await client.getProfile()
+
+      expect(profile.user_id).toBe('user42')
+      expect(profile.nickname).toBe('Test User')
+      expect(profile.profile_image_url).toBe('https://example.com/profile.jpg')
+      expect(profile.original_profile_image_url).toBe('https://example.com/original.jpg')
+      expect(profile.status_message).toBe('Hello world')
+      expect(profile.account_display_id).toBe('testuser123')
+
+      client.close()
+    })
+
+    test('throws not_authenticated when not logged in', async () => {
+      const client = new KakaoTalkClient()
+      try {
+        await client.getProfile()
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('not_authenticated')
+      }
+    })
+
+    test('throws profile_request_failed when profile HTTP request fails', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({}, 401))
+        .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: null }))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      try {
+        await client.getProfile()
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('profile_request_failed')
+      }
+
+      client.close()
+    })
+
+    test('returns null account_display_id when more_settings request fails', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({
+          profile: {
+            nickName: 'Test User',
+            profileImageUrl: null,
+            originalProfileImageUrl: null,
+            statusMessage: null,
+          },
+        }))
+        .mockResolvedValueOnce(makeJsonResponse({}, 500))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const profile = await client.getProfile()
+
+      expect(profile.user_id).toBe('user42')
+      expect(profile.nickname).toBe('Test User')
+      expect(profile.account_display_id).toBeNull()
+
+      client.close()
+    })
+  })
+
   describe('session lifecycle', () => {
     test('lazy init: does not call login until first method call', async () => {
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -399,8 +567,8 @@ describe('KakaoTalkClient', () => {
     })
 
     test('reuses session across multiple calls', async () => {
-      mockSyncMessages.mockResolvedValue({
-        body: { chatLogs: [], isOK: true },
+      mockGetChatLogs.mockResolvedValue({
+        body: { status: 0, chatLogs: [], eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -417,8 +585,8 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockImplementation(
         () => new Promise((resolve) => setTimeout(() => resolve(DEFAULT_LOGIN_RESULT), 50)),
       )
-      mockSyncMessages.mockResolvedValue({
-        body: { chatLogs: [], isOK: true },
+      mockGetChatLogs.mockResolvedValue({
+        body: { status: 0, chatLogs: [], eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })

package/src/platforms/kakaotalk/client.ts

@@ -1,10 +1,15 @@
 import { Long } from 'bson'
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
 
 import { warn } from '@/shared/utils/stderr'
 
+import { APP_VERSION, LANG, OS } from './protocol/config'
 import { LocoSession } from './protocol/session'
-import type { ChatListResponse, LoginListResponse } from './protocol/types'
-import type { KakaoChat, KakaoMessage, KakaoSendResult } from './types'
+import type { ChatListResponse, LoginListResponse, SyncState } from './protocol/types'
+import type { KakaoChat, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
 
 export class KakaoTalkError extends Error {
   code: string
@@ -73,6 +78,14 @@ function matchesSearch(chat: ChatData, term: string): boolean {
   return names.some((n) => n.toLowerCase().includes(lower))
 }
 
+function findMaxLogId(logs: Array<Record<string, unknown>>, field: string): Long | null {
+  return logs.reduce<Long | null>((max, log) => {
+    const current = bsonToLong(log[field])
+    if (!current) return max
+    return !max || current.greaterThan(max) ? current : max
+  }, null)
+}
+
 function collectChats(chatDatas: ChatData[], into: ChatData[], seen: Set<string>): void {
   for (const chat of chatDatas) {
     const id = String(chat.c)
@@ -91,6 +104,129 @@ function wrapError(error: unknown, code: string): KakaoTalkError {
 
 const MAX_PAGES = 50
 
+const CONFIG_DIR = join(homedir(), '.config', 'agent-messenger')
+
+function syncStatePath(deviceUuid: string): string {
+  return join(CONFIG_DIR, `kakaotalk-sync-state-${deviceUuid}.json`)
+}
+
+async function loadSyncState(deviceUuid: string): Promise<SyncState | undefined> {
+  const path = syncStatePath(deviceUuid)
+  if (!existsSync(path)) return undefined
+  const content = await readFile(path, 'utf-8')
+  const parsed = JSON.parse(content) as Partial<SyncState>
+
+  if (
+    parsed.version !== 2 ||
+    typeof parsed.revision !== 'number' ||
+    !Array.isArray(parsed.chatIds) ||
+    !Array.isArray(parsed.maxIds) ||
+    parsed.chatIds.length !== parsed.maxIds.length ||
+    !parsed.lastTokenId ||
+    typeof parsed.lbk !== 'number'
+  ) {
+    return undefined
+  }
+
+  return parsed as SyncState
+}
+
+async function saveSyncState(deviceUuid: string, state: SyncState): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true })
+  const path = syncStatePath(deviceUuid)
+  await writeFile(path, JSON.stringify(state, null, 2))
+  await chmod(path, 0o600)
+}
+
+function toLongLike(v: unknown): { low: number; high: number } {
+  if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+    const { low, high } = v as { low: number; high: number }
+    return { low, high }
+  }
+  if (typeof v === 'number') {
+    const big = BigInt(v)
+    return { low: Number(big & 0xffffffffn), high: Number((big >> 32n) & 0xffffffffn) }
+  }
+  return { low: 0, high: 0 }
+}
+
+function buildSyncState(loginResult: LoginListResponse, previousRevision: number): SyncState {
+  const chatDatas = (loginResult.chatDatas ?? []) as Array<Record<string, unknown>>
+  return {
+    version: 2,
+    revision: typeof loginResult.revision === 'number' ? loginResult.revision : previousRevision,
+    chatIds: chatDatas.map((chat) => toLongLike(chat.c)),
+    maxIds: chatDatas.map((chat) => toLongLike(chat.ll)),
+    lastTokenId: toLongLike(loginResult.lastTokenId),
+    lbk: typeof loginResult.lbk === 'number' ? loginResult.lbk : 0,
+  }
+}
+
+function deleteFromSyncState(state: SyncState, chatId: string): void {
+  const index = state.chatIds.findIndex((entry) => longToString(entry) === chatId)
+  if (index === -1) return
+
+  state.chatIds.splice(index, 1)
+  state.maxIds.splice(index, 1)
+}
+
+function upsertSyncState(state: SyncState, chatId: unknown, maxId: unknown): void {
+  const chatIdString = longToString(chatId)
+  const nextChatId = toLongLike(chatId)
+  const nextMaxId = toLongLike(maxId)
+  const index = state.chatIds.findIndex((entry) => longToString(entry) === chatIdString)
+
+  if (index === -1) {
+    state.chatIds.push(nextChatId)
+    state.maxIds.push(nextMaxId)
+    return
+  }
+
+  state.chatIds[index] = nextChatId
+  state.maxIds[index] = nextMaxId
+}
+
+function mergeSyncState(previous: SyncState | undefined, loginResult: LoginListResponse): SyncState {
+  const next = previous
+    ? {
+        version: 2 as const,
+        revision: previous.revision,
+        chatIds: [...previous.chatIds],
+        maxIds: [...previous.maxIds],
+        lastTokenId: previous.lastTokenId,
+        lbk: previous.lbk,
+      }
+    : buildSyncState(loginResult, 0)
+
+  next.revision = typeof loginResult.revision === 'number' ? loginResult.revision : next.revision
+  next.lastTokenId = toLongLike(loginResult.lastTokenId)
+  next.lbk = typeof loginResult.lbk === 'number' ? loginResult.lbk : next.lbk
+
+  const delChatIds = Array.isArray(loginResult.delChatIds) ? loginResult.delChatIds : []
+  for (const chatId of delChatIds) {
+    deleteFromSyncState(next, longToString(chatId))
+  }
+
+  const chatDatas = Array.isArray(loginResult.chatDatas) ? loginResult.chatDatas : []
+  for (const chat of chatDatas) {
+    upsertSyncState(next, chat.c, chat.ll)
+  }
+
+  return next
+}
+
+function formatMessages(logs: Array<Record<string, unknown>>, count: number): KakaoMessage[] {
+  logs.sort((a, b) => (a.sendAt as number) - (b.sendAt as number))
+
+  return logs.slice(-count).map((log) => ({
+    log_id: longToString(log.logId),
+    type: log.type as number,
+    author_id: log.authorId as number,
+    message: log.message as string,
+    sent_at: log.sendAt as number,
+  }))
+}
+
 export class KakaoTalkClient {
   private oauthToken: string | null = null
   private userId: string | null = null
@@ -178,7 +314,11 @@ export class KakaoTalkClient {
   private async connect(): Promise<SessionState> {
     const session = new LocoSession()
     try {
-      const loginResult = await session.login(this.oauthToken!, this.userId!, this.deviceUuid!)
+      const syncState = await loadSyncState(this.deviceUuid!)
+      const loginResult = await session.login(this.oauthToken!, this.userId!, this.deviceUuid!, syncState)
+
+      const newSyncState = mergeSyncState(syncState, loginResult)
+      await saveSyncState(this.deviceUuid!, newSyncState)
 
       session.onClose(() => {
         if (this.state?.session === session) {
@@ -206,11 +346,22 @@ export class KakaoTalkClient {
 
         collectChats((loginResult.chatDatas ?? []) as ChatData[], allChats, seenChatIds)
 
-        if (options?.all || options?.search) {
+        // Paginate via LCHATLIST when explicitly requested (--all / --search) OR when
+        // the login snapshot is empty. New device registrations often return an empty
+        // chatDatas with eof=true because the server has no prior sync state for the
+        // device — LCHATLIST fetches the canonical chat list regardless of device history.
+        const snapshotEmpty = allChats.length === 0
+        if (options?.all || options?.search || snapshotEmpty) {
           let cursor: ChatListResponse = loginResult
           let pages = 0
 
-          while (!cursor.eof && pages < MAX_PAGES) {
+          while (pages < MAX_PAGES) {
+            // Trust eof only when the snapshot had data. When the snapshot was empty
+            // (new device), ignore eof for the first iteration so we always attempt
+            // at least one LCHATLIST call.
+            if (cursor.eof && !snapshotEmpty) break
+            if (cursor.eof && snapshotEmpty && pages > 0) break
+
             const lastTokenId = bsonToLong(cursor.lastTokenId)
             const lastChatId = bsonToLong(cursor.lastChatId)
 
@@ -241,21 +392,62 @@ export class KakaoTalkClient {
   }
 
   async getMessages(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessage[]> {
-    return this.executeWithReconnect(async ({ session, loginResult }) => {
+    return this.executeWithReconnect(async ({ session }) => {
       try {
-        const rawChats = (loginResult.chatDatas ?? []) as ChatData[]
-        const chat = rawChats.find((c) => String(c.c) === chatId)
-        const lastLogId = chat?.ll as { high: number; low: number } | undefined
-        const maxLogId = lastLogId ? new Long(lastLogId.low, lastLogId.high) : undefined
-
         const count = options?.count ?? 20
         const cursor = options?.from ? parseLong(options.from) : undefined
 
         const cid = parseLong(chatId)
-        const startCursor = cursor ?? Long.fromNumber(0)
+
         const allMessages: Array<Record<string, unknown>> = []
         const seenLogIds = new Set<string>()
-        let cur = startCursor
+        let cur = cursor ?? Long.fromNumber(0)
+
+        try {
+          for (let page = 0; page < MAX_PAGES; page++) {
+            const response = await session.getChatLogs([cid], [cur])
+            const responseStatus = response.body.status
+            if (typeof responseStatus === 'number' && responseStatus !== 0) {
+              throw new Error(`MCHATLOGS failed: ${responseStatus}`)
+            }
+
+            const batch = ((response.body.chatLogs ?? []) as Array<Record<string, unknown>>).filter(
+              (log) => longToString(log.chatId) === chatId,
+            )
+            if (batch.length === 0) {
+              return formatMessages(allMessages, count)
+            }
+
+            for (const log of batch) {
+              const lid = longToString(log.logId)
+              if (!seenLogIds.has(lid)) {
+                seenLogIds.add(lid)
+                allMessages.push(log)
+              }
+            }
+
+            const maxLog = findMaxLogId(batch, 'logId')
+            if (!maxLog || maxLog.equals(cur) || response.body.eof) {
+              return formatMessages(allMessages, count)
+            }
+
+            cur = maxLog
+          }
+        } catch {
+          allMessages.length = 0
+          seenLogIds.clear()
+          cur = cursor ?? Long.fromNumber(0)
+        }
+
+        if (allMessages.length > 0) {
+          warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`)
+          return formatMessages(allMessages, count)
+        }
+
+        // Fetch fresh lastLogId via CHATONROOM (not the stale login-time snapshot)
+        const chatInfo = await session.getChatInfo(cid)
+        const chatBody = chatInfo.body as Record<string, unknown>
+        const maxLogId = bsonToLong(chatBody.l)
 
         let reachedEnd = false
         for (let page = 0; page < MAX_PAGES; page++) {
@@ -271,11 +463,7 @@ export class KakaoTalkClient {
             }
           }
 
-          const maxLog = batch.reduce<Long | null>((max, l) => {
-            const lid = l.logId as { high: number; low: number }
-            const long = new Long(lid.low, lid.high)
-            return !max || long.greaterThan(max) ? long : max
-          }, null)
+          const maxLog = findMaxLogId(batch, 'logId')
 
           if (!maxLog || maxLog.equals(cur) || response.body.isOK) { reachedEnd = true; break }
           cur = maxLog
@@ -284,15 +472,7 @@ export class KakaoTalkClient {
           warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`)
         }
 
-        allMessages.sort((a, b) => (a.sendAt as number) - (b.sendAt as number))
-
-        return allMessages.slice(-count).map((log) => ({
-          log_id: longToString(log.logId),
-          type: log.type as number,
-          author_id: log.authorId as number,
-          message: log.message as string,
-          sent_at: log.sendAt as number,
-        }))
+        return formatMessages(allMessages, count)
       } catch (error) {
         throw wrapError(error, 'get_messages_failed')
       }
@@ -317,6 +497,60 @@ export class KakaoTalkClient {
     })
   }
 
+  async getProfile(): Promise<KakaoProfile> {
+    this.ensureAuth()
+    try {
+      const headers = {
+        Authorization: `${this.oauthToken}-${this.deviceUuid}`,
+        A: `${OS}/${APP_VERSION}/${LANG}`,
+        'User-Agent': `KT/${APP_VERSION} Md/macOS ${LANG}`,
+        Accept: '*/*',
+        'Accept-Language': LANG,
+      }
+
+      const [profileRes, settingsRes] = await Promise.all([
+        fetch('https://katalk.kakao.com/mac/profile3/me.json', { headers }),
+        fetch('https://katalk.kakao.com/mac/account/more_settings.json?since=0&lang=ko', { headers }),
+      ])
+
+      if (!profileRes.ok) {
+        throw new KakaoTalkError(`Profile request failed: ${profileRes.status}`, 'profile_request_failed')
+      }
+
+      const profileData = await profileRes.json() as Record<string, unknown>
+      const profile = profileData.profile as Record<string, unknown> | undefined
+
+      let accountDisplayId: string | null = null
+      let accountEmail: string | null = null
+      let pstnNumber: string | null = null
+      let emailVerified: boolean | null = null
+      if (settingsRes.ok) {
+        const settingsData = await settingsRes.json() as Record<string, unknown>
+        accountDisplayId = (settingsData.accountDisplayId as string) || null
+        accountEmail = (settingsData.accountEmail as string) || null
+        pstnNumber = (settingsData.pstnNumber as string) || null
+        emailVerified = typeof settingsData.emailVerified === 'boolean' ? settingsData.emailVerified : null
+      }
+
+      return {
+        user_id: this.userId!,
+        nickname: (profile?.nickName as string) || '',
+        profile_image_url: (profile?.profileImageUrl as string) || null,
+        original_profile_image_url: (profile?.originalProfileImageUrl as string) || null,
+        background_image_url: (profile?.backgroundImageUrl as string) || null,
+        original_background_image_url: (profile?.originalBackgroundImageUrl as string) || null,
+        fullname: (profile?.fullname as string) || null,
+        status_message: (profile?.statusMessage as string) || null,
+        account_display_id: accountDisplayId,
+        account_email: accountEmail,
+        pstn_number: pstnNumber,
+        email_verified: emailVerified,
+      }
+    } catch (error) {
+      throw wrapError(error, 'get_profile_failed')
+    }
+  }
+
   close(): void {
     this.closed = true
     if (this.state) {