agent-messenger 2.4.0 → 2.6.0

package/src/platforms/kakaotalk/client.ts

@@ -1,11 +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 { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
 import { LocoSession } from './protocol/session'
-import type { ChatListResponse, LoginListResponse } from './protocol/types'
-import type { KakaoChat, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
+import type { ChatListResponse, LoginListResponse, SyncState } from './protocol/types'
+import type { KakaoChat, KakaoDeviceType, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
 
 export class KakaoTalkError extends Error {
   code: string
@@ -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,16 +104,140 @@ 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
   private deviceUuid: string | null = null
+  private deviceType: KakaoDeviceType = 'tablet'
   private state: SessionState | null = null
   private initPromise: Promise<SessionState> | null = null
   private closed = false
 
   async login(
-    credentials?: { oauthToken: string; userId: string; deviceUuid?: string },
+    credentials?: { oauthToken: string; userId: string; deviceUuid?: string; deviceType?: KakaoDeviceType },
     accountId?: string,
   ): Promise<this> {
     if (credentials) {
@@ -110,19 +246,26 @@ export class KakaoTalkClient {
       this.oauthToken = credentials.oauthToken
       this.userId = credentials.userId
       this.deviceUuid = credentials.deviceUuid ?? `agent-messenger-${credentials.userId}`
+      this.deviceType = credentials.deviceType ?? 'tablet'
       return this
     }
     const { ensureKakaoAuth } = await import('./ensure-auth')
     const account = await ensureKakaoAuth(accountId)
-    return this.login({ oauthToken: account.oauth_token, userId: account.user_id, deviceUuid: account.device_uuid })
+    return this.login({
+      oauthToken: account.oauth_token,
+      userId: account.user_id,
+      deviceUuid: account.device_uuid,
+      deviceType: account.device_type,
+    })
   }
 
-  getCredentials(): { oauthToken: string; userId: string; deviceUuid: string } {
+  getCredentials(): { oauthToken: string; userId: string; deviceUuid: string; deviceType: KakaoDeviceType } {
     this.ensureAuth()
     return {
       oauthToken: this.oauthToken!,
       userId: this.userId!,
       deviceUuid: this.deviceUuid!,
+      deviceType: this.deviceType,
     }
   }
 
@@ -179,7 +322,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, this.deviceType)
+
+      const newSyncState = mergeSyncState(syncState, loginResult)
+      await saveSyncState(this.deviceUuid!, newSyncState)
 
       session.onClose(() => {
         if (this.state?.session === session) {
@@ -253,21 +400,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 +471,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 +480,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')
       }
@@ -332,17 +508,24 @@ export class KakaoTalkClient {
   async getProfile(): Promise<KakaoProfile> {
     this.ensureAuth()
     try {
+      const deviceConfig = getLocoDeviceConfig(this.deviceType)
+      const isPC = deviceConfig.os !== 'android'
+      const apiPrefix = isPC ? 'mac' : 'android'
+      const userAgent = isPC
+        ? `KT/${deviceConfig.appVersion} Md/${PC_OS_NAME} ${LANG}`
+        : `KT/${deviceConfig.appVersion} An/13 ${LANG}`
+
       const headers = {
         Authorization: `${this.oauthToken}-${this.deviceUuid}`,
-        A: `${OS}/${APP_VERSION}/${LANG}`,
-        'User-Agent': `KT/${APP_VERSION} Md/macOS ${LANG}`,
+        A: `${deviceConfig.os}/${deviceConfig.appVersion}/${LANG}`,
+        'User-Agent': userAgent,
         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 }),
+        fetch(`https://katalk.kakao.com/${apiPrefix}/profile3/me.json`, { headers }),
+        fetch(`https://katalk.kakao.com/${apiPrefix}/account/more_settings.json?since=0&lang=ko`, { headers }),
       ])
 
       if (!profileRes.ok) {
@@ -353,9 +536,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 +552,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/auth.ts

@@ -6,7 +6,7 @@ import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { info, error, debug } from '@/shared/utils/stderr'
 
-import { generateDeviceUuid, loginFlow } from '../auth/kakao-login'
+import { loginFlow } from '../auth/kakao-login'
 import { CredentialManager } from '../credential-manager'
 import { KakaoTokenExtractor } from '../token-extractor'
 import {
@@ -23,7 +23,9 @@ function isInteractiveSession(): boolean {
 function hasTTY(): boolean {
   try {
     const { openSync, closeSync } = require('node:fs') as typeof import('node:fs')
-    const fd = openSync('/dev/tty', 'r')
+    // CONIN$ is the Windows console input device; /dev/tty is the Unix equivalent
+    const ttyDevice = process.platform === 'win32' ? 'CONIN$' : '/dev/tty'
+    const fd = openSync(ttyDevice, 'r')
     closeSync(fd)
     return true
   } catch { return false }
@@ -178,6 +180,20 @@ async function promptHidden(message: string): Promise<string | undefined> {
 }
 
 async function promptHiddenTTY(message: string): Promise<string | undefined> {
+  if (process.platform === 'win32') {
+    const { execSync } = require('node:child_process') as typeof import('node:child_process')
+    try {
+      const escapedMessage = message.replace(/'/g, "''")
+      const ps = `$p = Read-Host '${escapedMessage}' -AsSecureString; [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($p))`
+      const result = execSync(`powershell -NoProfile -Command "${ps}"`, {
+        encoding: 'utf-8',
+        timeout: 120_000,
+        stdio: ['inherit', 'pipe', 'inherit'],
+      })
+      return result.trim() || undefined
+    } catch { return undefined }
+  }
+
   const { createReadStream } = await import('node:fs')
   const { createInterface } = await import('node:readline/promises')
   const ttyIn = createReadStream('/dev/tty')
@@ -277,7 +293,8 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
 
     const existing = await credManager.getAccount()
     const pendingState = await credManager.loadPendingLogin()
-    const savedDeviceUuid = pendingState?.device_uuid ?? existing?.device_uuid
+    const existingUuid = existing?.auth_method === 'login' ? existing?.device_uuid : undefined
+    const savedDeviceUuid = pendingState?.device_uuid ?? existingUuid
 
     const onPasscodeDisplay = (code: string) => {
       if (interactive) {
@@ -355,6 +372,7 @@ async function handleLoginResult(
       refresh_token: result.credentials.refresh_token,
       device_uuid: result.credentials.device_uuid,
       device_type: result.credentials.device_type,
+      auth_method: 'login',
       created_at: now,
       updated_at: now,
     })
@@ -372,67 +390,6 @@ async function handleLoginResult(
   }
 }
 
-async function extractAction(options: {
-  pretty?: boolean
-  debug?: boolean
-  unsafelyShowSecrets?: boolean
-}): Promise<void> {
-  try {
-    if (options.unsafelyShowSecrets) {
-      options.debug = true
-    }
-    const debugLog = options.debug ? (msg: string) => debug(`[debug] ${msg}`) : undefined
-    const extractor = new KakaoTokenExtractor(undefined, debugLog)
-
-    const token = await extractor.extract()
-
-    if (!token) {
-      console.log(
-        formatOutput(
-          {
-            error: 'No credentials found. Make sure KakaoTalk desktop app is installed and logged in.',
-            hint: options.debug ? undefined : 'Run with --debug for more info.',
-          },
-          options.pretty,
-        ),
-      )
-      process.exit(1)
-    }
-
-    if (options.debug) {
-      const display = options.unsafelyShowSecrets
-        ? token.oauth_token
-        : `${token.oauth_token.substring(0, 12)}...`
-      debug(`[debug] oauth_token: ${display}`)
-      debug(`[debug] user_id: ${token.user_id}`)
-    }
-
-    const credManager = new CredentialManager()
-    const accountId = token.user_id || 'default'
-    const now = new Date().toISOString()
-
-    await credManager.setAccount({
-      account_id: accountId,
-      oauth_token: token.oauth_token,
-      user_id: token.user_id,
-      refresh_token: token.refresh_token,
-      device_uuid: token.device_uuid ?? generateDeviceUuid(),
-      device_type: 'tablet',
-      created_at: now,
-      updated_at: now,
-    })
-
-    const config = await credManager.load()
-    if (!config.current_account) {
-      await credManager.setCurrentAccount(accountId)
-    }
-
-    console.log(formatOutput({ account_id: accountId, user_id: token.user_id, extracted: true }, options.pretty))
-  } catch (error) {
-    handleError(error as Error)
-  }
-}
-
 async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new CredentialManager()
@@ -483,7 +440,7 @@ async function statusAction(options: { account?: string; pretty?: boolean }): Pr
     const account = await credManager.getAccount(options.account)
 
     if (!account) {
-      console.log(formatOutput({ error: 'No account configured. Run "auth login" or "auth extract" first.' }, options.pretty))
+      console.log(formatOutput({ error: 'No account configured. Run "auth login" first.' }, options.pretty))
       process.exit(1)
     }
 
@@ -533,14 +490,6 @@ export const authCommand = new Command('auth')
       .option('--debug', 'Show debug output')
       .action(loginAction),
   )
-  .addCommand(
-    new Command('extract')
-      .description('Extract credentials from KakaoTalk desktop app (kicks desktop session)')
-      .option('--pretty', 'Pretty print JSON output')
-      .option('--debug', 'Show debug output for troubleshooting')
-      .option('--unsafely-show-secrets', 'Show full token values in debug output')
-      .action(extractAction),
-  )
   .addCommand(
     new Command('list')
       .description('List all authenticated KakaoTalk accounts')

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'

package/src/platforms/kakaotalk/commands/{profile.test.ts → whoami.test.ts}

@@ -13,6 +13,15 @@ const mockGetProfile = mock(() =>
     user_id: 'user-1',
     nickname: 'Test User',
     profile_image_url: 'https://example.com/avatar.jpg',
+    original_profile_image_url: 'https://example.com/avatar_orig.jpg',
+    background_image_url: 'https://example.com/bg.jpg',
+    original_background_image_url: 'https://example.com/bg_orig.jpg',
+    fullname: 'Real Name',
+    status_message: 'Hello!',
+    account_display_id: 'testuser',
+    account_email: 'test@example.com',
+    pstn_number: '+821012345678',
+    email_verified: true,
   }),
 )
 
@@ -24,9 +33,9 @@ mock.module('./shared', () => ({
   withKakaoClient: mockWithKakaoClient,
 }))
 
-import { profileCommand } from './profile'
+import { whoamiCommand } from './whoami'
 
-describe('profile command', () => {
+describe('whoami command', () => {
   let consoleLogSpy: ReturnType<typeof mock>
 
   beforeEach(() => {
@@ -43,6 +52,15 @@ describe('profile command', () => {
         user_id: 'user-1',
         nickname: 'Test User',
         profile_image_url: 'https://example.com/avatar.jpg',
+        original_profile_image_url: 'https://example.com/avatar_orig.jpg',
+        background_image_url: 'https://example.com/bg.jpg',
+        original_background_image_url: 'https://example.com/bg_orig.jpg',
+        fullname: 'Real Name',
+        status_message: 'Hello!',
+        account_display_id: 'testuser',
+        account_email: 'test@example.com',
+        pstn_number: '+821012345678',
+        email_verified: true,
       }),
     )
 
@@ -55,7 +73,7 @@ describe('profile command', () => {
   })
 
   test('outputs profile information', async () => {
-    await profileCommand.parseAsync([], { from: 'user' })
+    await whoamiCommand.parseAsync([], { from: 'user' })
 
     expect(mockGetProfile).toHaveBeenCalled()
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -64,8 +82,22 @@ describe('profile command', () => {
     expect(output.profile_image_url).toBe('https://example.com/avatar.jpg')
   })
 
+  test('outputs enriched profile fields', async () => {
+    await whoamiCommand.parseAsync([], { from: 'user' })
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+    expect(output.background_image_url).toBe('https://example.com/bg.jpg')
+    expect(output.original_background_image_url).toBe('https://example.com/bg_orig.jpg')
+    expect(output.fullname).toBe('Real Name')
+    expect(output.status_message).toBe('Hello!')
+    expect(output.account_display_id).toBe('testuser')
+    expect(output.account_email).toBe('test@example.com')
+    expect(output.pstn_number).toBe('+821012345678')
+    expect(output.email_verified).toBe(true)
+  })
+
   test('passes account option to withKakaoClient', async () => {
-    await profileCommand.parseAsync(['--account', 'my-account'], { from: 'user' })
+    await whoamiCommand.parseAsync(['--account', 'my-account'], { from: 'user' })
 
     expect(mockWithKakaoClient).toHaveBeenCalledWith(
       expect.objectContaining({ account: 'my-account' }),
@@ -74,7 +106,7 @@ describe('profile command', () => {
   })
 
   test('outputs profile with pretty flag', async () => {
-    await profileCommand.parseAsync(['--pretty'], { from: 'user' })
+    await whoamiCommand.parseAsync(['--pretty'], { from: 'user' })
 
     expect(mockGetProfile).toHaveBeenCalled()
     const rawOutput = consoleLogSpy.mock.calls[0][0]

package/src/platforms/kakaotalk/commands/{profile.ts → whoami.ts}

@@ -5,7 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { withKakaoClient } from './shared'
 
-async function profileAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+async function whoamiAction(options: { account?: string; pretty?: boolean }): Promise<void> {
   try {
     const profile = await withKakaoClient(options, (client) => client.getProfile())
     console.log(formatOutput(profile, options.pretty))
@@ -14,8 +14,8 @@ async function profileAction(options: { account?: string; pretty?: boolean }): P
   }
 }
 
-export const profileCommand = new Command('profile')
-  .description('Show your KakaoTalk profile')
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
   .option('--account <id>', 'Use a specific KakaoTalk account')
   .option('--pretty', 'Pretty print JSON output')
-  .action(profileAction)
+  .action(whoamiAction)

package/src/platforms/kakaotalk/credential-manager.ts

@@ -34,6 +34,7 @@ export class KakaoCredentialManager {
 
   async save(config: KakaoConfig): Promise<void> {
     await mkdir(this.configDir, { recursive: true })
+    // TODO: Windows does not honor mode 0o600 — consider platform-specific credential storage
     await writeFile(this.credentialsPath, JSON.stringify(config, null, 2))
     await chmod(this.credentialsPath, 0o600)
   }

package/src/platforms/kakaotalk/index.ts

@@ -4,6 +4,7 @@ export { KakaoTalkListener } from './listener'
 export type { PendingLoginState } from './credential-manager'
 export type {
   KakaoAccountCredentials,
+  KakaoAuthMethod,
   KakaoChat,
   KakaoConfig,
   KakaoDeviceType,

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

@@ -45,7 +45,7 @@ mock.module('./protocol/session', () => ({ LocoSession: MockLocoSession }))
 
 function createMockClient(overrides: Record<string, unknown> = {}) {
   return {
-    getCredentials: mock(() => ({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })),
+    getCredentials: mock(() => ({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1', deviceType: 'tablet' as const })),
     ...overrides,
   } as any
 }
@@ -68,7 +68,7 @@ describe('KakaoTalkListener', () => {
       await listener.start()
 
       expect(mockLogin).toHaveBeenCalledTimes(1)
-      expect(mockLogin).toHaveBeenCalledWith('token', 'user1', 'device1')
+      expect(mockLogin).toHaveBeenCalledWith('token', 'user1', 'device1', undefined, 'tablet')
     })
 
     test('is idempotent', async () => {