agent-messenger 2.4.0 → 2.5.0

package/src/platforms/discordbot/commands/whoami.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: string
+  username?: string
+  global_name?: string
+  avatar?: string
+  bot?: boolean
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.testAuth()
+    return {
+      id: info.id,
+      username: info.username,
+      global_name: info.global_name,
+      avatar: info.avatar,
+      bot: info.bot,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--bot <id>', 'Bot ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/platforms/instagram/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, messageCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureInstagramAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -31,6 +31,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

package/src/platforms/instagram/client.ts

@@ -410,6 +410,19 @@ export class InstagramClient {
     return this.userId
   }
 
+  async getProfile(): Promise<{ user_id: string; username: string; full_name: string | null; profile_pic_url: string | null }> {
+    if (!this.userId) {
+      throw new InstagramError('Not authenticated. Call login() first.', 'not_authenticated')
+    }
+    const account = await this.credentialManager.getAccount()
+    return {
+      user_id: this.userId,
+      username: account?.username ?? '',
+      full_name: account?.full_name ?? null,
+      profile_pic_url: account?.profile_pic_url ?? null,
+    }
+  }
+
   private async preLoginFlow(): Promise<{ keyId: string; publicKey: string } | null> {
     const url = `${IG_BASE_URL}/qe/sync/`
     const headers = this.buildHeaders()

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
@@ -34,10 +34,6 @@ function resetCommandState(cmd: Command): void {
   }
 }
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('chat commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>

package/src/platforms/instagram/commands/index.ts

@@ -1,3 +1,4 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
 export { messageCommand } from './message'
+export { whoamiCommand } from './whoami'

package/src/platforms/instagram/commands/message.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
@@ -32,10 +32,6 @@ function resetCommandState(cmd: Command): void {
   }
 }
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('message commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>

package/src/platforms/instagram/commands/whoami.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+import { whoamiAction } from './whoami'
+
+let withInstagramClientSpy: ReturnType<typeof spyOn>
+let getProfileSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    getProfileSpy = spyOn(InstagramClient.prototype, 'getProfile').mockResolvedValue({
+      user_id: '987654321',
+      username: 'testuser',
+      full_name: 'Test User',
+      profile_pic_url: 'https://example.com/pic.jpg',
+    })
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(
+      async (_opts, fn) => {
+        const fakeClient = Object.create(InstagramClient.prototype) as InstagramClient
+        return fn(fakeClient)
+      },
+    )
+    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    getProfileSpy?.mockRestore()
+    withInstagramClientSpy?.mockRestore()
+    consoleLogSpy?.mockRestore()
+  })
+
+  test('outputs profile information', async () => {
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.user_id).toBe('987654321')
+    expect(output.username).toBe('testuser')
+    expect(output.full_name).toBe('Test User')
+    expect(output.profile_pic_url).toBe('https://example.com/pic.jpg')
+  })
+
+  test('outputs profile with null optional fields', async () => {
+    getProfileSpy.mockResolvedValue({
+      user_id: '987654321',
+      username: 'testuser',
+      full_name: null,
+      profile_pic_url: null,
+    })
+
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.full_name).toBeNull()
+    expect(output.profile_pic_url).toBeNull()
+  })
+})

package/src/platforms/instagram/commands/whoami.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { withInstagramClient } from './shared'
+
+export async function whoamiAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const profile = await withInstagramClient(options, (client) => client.getProfile())
+    console.log(formatOutput(profile, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--account <id>', 'Use a specific Instagram account')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/kakaotalk/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, messageCommand, profileCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureKakaoAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -31,7 +31,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
-program.addCommand(profileCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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(() => {
@@ -316,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,
         },
       })
 
@@ -351,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' })
@@ -373,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,
         },
       })
 
@@ -556,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' })
@@ -574,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,14 @@
 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 { ChatListResponse, LoginListResponse, SyncState } from './protocol/types'
 import type { KakaoChat, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
 
 export class KakaoTalkError extends Error {
@@ -74,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)
@@ -92,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
@@ -179,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) {
@@ -253,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++) {
@@ -283,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
@@ -296,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')
       }
@@ -353,9 +521,15 @@ export class KakaoTalkClient {
       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 {
@@ -363,8 +537,14 @@ export class KakaoTalkClient {
         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')

package/src/platforms/kakaotalk/commands/index.ts

@@ -1,4 +1,4 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
 export { messageCommand } from './message'
-export { profileCommand } from './profile'
+export { whoamiCommand } from './whoami'