agent-messenger 2.4.0 → 2.6.0

package/src/platforms/kakaotalk/listener.ts

@@ -72,7 +72,7 @@ export class KakaoTalkListener {
     if (!this.running) return
 
     try {
-      const { oauthToken, userId, deviceUuid } = this.client.getCredentials()
+      const { oauthToken, userId, deviceUuid, deviceType } = this.client.getCredentials()
       if (!this.running) return
 
       this.userId = userId
@@ -88,7 +88,7 @@ export class KakaoTalkListener {
         }
       })
 
-      await session.login(oauthToken, userId, deviceUuid)
+      await session.login(oauthToken, userId, deviceUuid, undefined, deviceType)
 
       if (!this.running) {
         session.close()

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

@@ -1,6 +1,8 @@
 // Protocol constants for KakaoTalk LOCO.
 // See protocol/NOTICE.md for attribution of protocol knowledge.
 
+import type { KakaoDeviceType } from '../types'
+
 // LOCO RSA public key (PKCS#1 DER, base64). RSA-2048, e=3.
 // Source: openkakao (MIT) — extracted from KakaoTalk macOS binary.
 export const LOCO_RSA_PUBLIC_KEY_DER_B64 =
@@ -17,8 +19,17 @@ export const BOOKING_PORT = 443
 export const CHECKIN_HOST = 'ticket-loco.kakao.com'
 export const CHECKIN_PORT = 995
 
-export const APP_VERSION = '26.2.0'
-export const OS = 'mac'
+// PC slot identity — platform-aware: 'win' on Windows, 'mac' on macOS
+const PC_APP_VERSION = '26.2.0'
+const PC_OS: string = process.platform === 'win32' ? 'win' : 'mac'
+export const PC_OS_NAME: string = process.platform === 'win32' ? 'Windows' : 'macOS'
+
+// Android (tablet slot) identity — must match the Android sub-device agent
+// used in auth/kakao-login.ts so the server sees a consistent tablet session.
+const ANDROID_APP_VERSION = '25.9.2'
+const ANDROID_OS = 'android'
+
+// dtype: 2 = sub-device, 1 = main device (ref: node-kakao config.ts)
 export const DTYPE = 2
 export const MCCMNC = '99999'
 export const LANG = 'ko'
@@ -26,3 +37,16 @@ export const COUNTRY_ISO = 'KR'
 export const PROTOCOL_VERSION = '1'
 
 export const PING_INTERVAL_MS = 300_000
+
+export interface LocoDeviceConfig {
+  os: string
+  appVersion: string
+  useSub: boolean
+}
+
+export function getLocoDeviceConfig(deviceType: KakaoDeviceType): LocoDeviceConfig {
+  if (deviceType === 'tablet') {
+    return { os: ANDROID_OS, appVersion: ANDROID_APP_VERSION, useSub: true }
+  }
+  return { os: PC_OS, appVersion: PC_APP_VERSION, useSub: false }
+}

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

@@ -1,7 +1,8 @@
 import { Binary, Long } from 'bson'
 
+import type { KakaoDeviceType } from '../types'
+
 import {
-  APP_VERSION,
   BOOKING_HOST,
   BOOKING_PORT,
   CHECKIN_HOST,
@@ -12,18 +13,23 @@ import {
   MCCMNC,
   PING_INTERVAL_MS,
   PROTOCOL_VERSION,
+  getLocoDeviceConfig,
 } 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
   private pingTimer: ReturnType<typeof setInterval> | null = null
   private pushHandler: ((packet: LocoPacket) => void) | null = null
   private closeHandler: (() => void) | null = null
+  private deviceType: KakaoDeviceType = 'tablet'
+
+  async login(oauthToken: string, userId: string, deviceUuid: string, syncState?: SyncState, deviceType?: KakaoDeviceType): Promise<LoginListResponse> {
+    this.deviceType = deviceType ?? 'tablet'
+    const deviceConfig = getLocoDeviceConfig(this.deviceType)
 
-  async login(oauthToken: string, userId: string, deviceUuid: string): Promise<LoginListResponse> {
-    const { host, port } = await this.bookAndCheckin(userId)
+    const { host, port } = await this.bookAndCheckin(userId, deviceConfig)
 
     this.connection = new LocoConnection()
     await this.connection.connectSecure(host, port)
@@ -35,21 +41,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,
+      appVer: deviceConfig.appVersion,
       prtVer: PROTOCOL_VERSION,
-      os: 'mac',
+      os: deviceConfig.os,
       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,
     })
@@ -58,12 +71,12 @@ export class LocoSession {
     return response.body as unknown as LoginListResponse
   }
 
-  private async bookAndCheckin(userId: string): Promise<{ host: string; port: number }> {
+  private async bookAndCheckin(userId: string, deviceConfig: { os: string; appVersion: string; useSub: boolean }): Promise<{ host: string; port: number }> {
     const bookingConn = new LocoConnection()
     await bookingConn.connectTls(BOOKING_HOST, BOOKING_PORT)
 
     const bookingResponse = await bookingConn.sendPacket('GETCONF', {
-      os: 'mac',
+      os: deviceConfig.os,
       model: '',
     })
     bookingConn.close()
@@ -79,13 +92,13 @@ export class LocoSession {
 
     const checkinResponse = await checkinConn.sendPacket('CHECKIN', {
       userId: Number(userId),
-      os: 'mac',
+      os: deviceConfig.os,
       ntype: 0,
-      appVer: APP_VERSION,
+      appVer: deviceConfig.appVersion,
       MCCMNC: MCCMNC,
       lang: LANG,
       countryISO: COUNTRY_ISO,
-      useSub: true,
+      useSub: deviceConfig.useSub,
     })
     checkinConn.close()
 
@@ -117,6 +130,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

@@ -11,6 +11,8 @@ export interface ExtractedKakaoToken {
   login_form_body?: string
 }
 
+export type KakaoAuthMethod = 'login' | 'extract'
+
 export interface KakaoAccountCredentials {
   account_id: string
   oauth_token: string
@@ -18,6 +20,7 @@ export interface KakaoAccountCredentials {
   refresh_token?: string
   device_uuid: string
   device_type: KakaoDeviceType
+  auth_method?: KakaoAuthMethod
   created_at: string
   updated_at: string
 }
@@ -130,8 +133,14 @@ export interface KakaoProfile {
   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({
@@ -139,8 +148,14 @@ export const KakaoProfileSchema = z.object({
   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({
@@ -150,6 +165,7 @@ export const KakaoAccountCredentialsSchema = z.object({
   refresh_token: z.string().optional(),
   device_uuid: z.string(),
   device_type: z.enum(['pc', 'tablet']),
+  auth_method: z.enum(['login', 'extract']).optional(),
   created_at: z.string(),
   updated_at: 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/commands/auth.ts

@@ -1,13 +1,8 @@
-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'
@@ -22,34 +17,6 @@ function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
 
-async function createQRHtmlFile(url: string): Promise<string> {
-  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)
-  setTimeout(() => { try { unlinkSync(htmlPath) } catch {} }, 300_000).unref()
-  return htmlPath
-}
-
-function openInBrowser(filePath: string): void {
-  try {
-    if (process.platform === 'darwin') {
-      execSync(`open "${filePath}"`, { stdio: 'ignore' })
-    } else if (process.platform === 'win32') {
-      execSync(`start "" "${filePath}"`, { stdio: 'ignore' })
-    } else {
-      execSync(`xdg-open "${filePath}"`, { stdio: 'ignore' })
-    }
-  } catch {}
-}
-
 async function loginAction(options: {
   email?: string
   password?: string
@@ -76,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`)
           }
@@ -98,27 +70,14 @@ async function loginAction(options: {
       const result = await client.loginWithQR({
         device,
         onQRUrl: async (url) => {
-          const htmlPath = await createQRHtmlFile(url).catch(() => null)
-          if (htmlPath) openInBrowser(htmlPath)
-
-          if (interactive) {
-            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`)
-            }
-          } else {
-            console.log(formatOutput({
-              next_action: 'scan_qr',
-              qr_url: url,
-              qr_html_path: htmlPath,
-              message: htmlPath
-                ? 'QR code opened in browser. Scan with LINE mobile app to complete login.'
-                : 'QR code generated. Open qr_url to scan with LINE mobile app.',
-            }, options.pretty))
-          }
+          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`)
@@ -141,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)
   }
@@ -196,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/index.ts

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

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

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
 const originalConsoleLog = console.log
 
 import { LineClient } from '../client'
-import { profileCommand } from './profile'
+import { whoamiCommand } from './whoami'
 
 let loginSpy: ReturnType<typeof spyOn>
 let getProfileSpy: ReturnType<typeof spyOn>
@@ -33,9 +33,9 @@ afterEach(() => {
   console.log = originalConsoleLog
 })
 
-test('profile: fetches and outputs profile', async () => {
+test('whoami: fetches and outputs profile', async () => {
   // when
-  await profileCommand.parseAsync(['node', 'profile'])
+  await whoamiCommand.parseAsync(['node', 'whoami'])
 
   // then
   expect(loginSpy).toHaveBeenCalledTimes(1)
@@ -46,9 +46,9 @@ test('profile: fetches and outputs profile', async () => {
   expect(output.display_name).toBe('Test User')
 })
 
-test('profile: outputs profile with all fields', async () => {
+test('whoami: outputs profile with all fields', async () => {
   // when
-  await profileCommand.parseAsync(['node', 'profile'])
+  await whoamiCommand.parseAsync(['node', 'whoami'])
 
   // then
   const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -58,26 +58,26 @@ test('profile: outputs profile with all fields', async () => {
   expect(output.status_message).toBeDefined()
 })
 
-test('profile: closes client after fetching profile', async () => {
+test('whoami: closes client after fetching profile', async () => {
   // when
-  await profileCommand.parseAsync(['node', 'profile'])
+  await whoamiCommand.parseAsync(['node', 'whoami'])
 
   // then
   expect(closeSpy).toHaveBeenCalledTimes(1)
 })
 
-test('profile: outputs profile with picture_url', async () => {
+test('whoami: outputs profile with picture_url', async () => {
   // when
-  await profileCommand.parseAsync(['node', 'profile'])
+  await whoamiCommand.parseAsync(['node', 'whoami'])
 
   // then
   const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
   expect(output.picture_url).toBe('https://example.com/pic.jpg')
 })
 
-test('profile: outputs profile with status_message', async () => {
+test('whoami: outputs profile with status_message', async () => {
   // when
-  await profileCommand.parseAsync(['node', 'profile'])
+  await whoamiCommand.parseAsync(['node', 'whoami'])
 
   // then
   const output = JSON.parse(consoleLogSpy.mock.calls[0][0])

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

@@ -5,7 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { LineClient } from '../client'
 
-async function profileAction(options: { pretty?: boolean }): Promise<void> {
+async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
   let client: LineClient | undefined
   try {
     client = await new LineClient().login()
@@ -18,7 +18,7 @@ async function profileAction(options: { pretty?: boolean }): Promise<void> {
   }
 }
 
-export const profileCommand = new Command('profile')
-  .description('Show your LINE profile')
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
   .option('--pretty', 'Pretty print JSON output')
-  .action(profileAction)
+  .action(whoamiAction)

package/src/platforms/slack/cli.ts

@@ -22,6 +22,7 @@ import {
   unreadCommand,
   userCommand,
   usergroupCommand,
+  whoamiCommand,
   workspaceCommand,
 } from './commands/index'
 import { ensureSlackAuth } from './ensure-auth'
@@ -66,6 +67,7 @@ program.addCommand(bookmarkCommand)
 program.addCommand(reminderCommand)
 program.addCommand(emojiCommand)
 program.addCommand(usergroupCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -15,4 +15,5 @@ export { snapshotCommand } from './snapshot'
 export { unreadCommand } from './unread'
 export { userCommand } from './user'
 export { usergroupCommand } from './usergroup'
+export { whoamiCommand } from './whoami'
 export { workspaceCommand } from './workspace'

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

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import { CredentialManager } from '@/platforms/slack/credential-manager'
+import { whoamiAction, whoamiCommand } from '@/platforms/slack/commands/whoami'
+
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let clientGetUserSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+const mockWorkspace = {
+  workspace_id: 'T123',
+  workspace_name: 'Test Workspace',
+  token: 'xoxc-test',
+  cookie: 'test-cookie',
+}
+
+const mockAuthInfo = {
+  user_id: 'U123',
+  team_id: 'T123',
+  user: 'alice',
+  team: 'Test Workspace',
+}
+
+const mockUser = {
+  id: 'U123',
+  name: 'alice',
+  real_name: 'Alice Smith',
+  is_admin: true,
+  is_owner: false,
+  is_bot: false,
+  is_app_user: false,
+  profile: {
+    email: 'alice@example.com',
+    title: 'Engineer',
+  },
+}
+
+beforeEach(() => {
+  credManagerSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue(mockWorkspace)
+  clientTestAuthSpy = spyOn(SlackClient.prototype, 'testAuth').mockResolvedValue(mockAuthInfo)
+  clientGetUserSpy = spyOn(SlackClient.prototype, 'getUser').mockResolvedValue(mockUser)
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  credManagerSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  clientGetUserSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+test('whoami command is defined with correct name and description', () => {
+  expect(whoamiCommand).toBeDefined()
+  expect(whoamiCommand.name()).toBe('whoami')
+  expect(whoamiCommand.description()).toBe('Show current authenticated user')
+})
+
+test('whoami command has --pretty option', () => {
+  const options = whoamiCommand.options
+  const hasPretty = options.some((opt: { long?: string }) => opt.long === '--pretty')
+  expect(hasPretty).toBe(true)
+})
+
+test('whoami outputs expected fields', async () => {
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'U123',
+      name: 'alice',
+      real_name: 'Alice Smith',
+      is_admin: true,
+      is_owner: false,
+      is_bot: false,
+      is_app_user: false,
+      team_id: 'T123',
+      team: 'Test Workspace',
+      profile: {
+        email: 'alice@example.com',
+        title: 'Engineer',
+      },
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+  await whoamiAction({ pretty: true })
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'U123',
+        name: 'alice',
+        real_name: 'Alice Smith',
+        is_admin: true,
+        is_owner: false,
+        is_bot: false,
+        is_app_user: false,
+        team_id: 'T123',
+        team: 'Test Workspace',
+        profile: {
+          email: 'alice@example.com',
+          title: 'Engineer',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with error when no workspace is set', async () => {
+  credManagerSpy.mockResolvedValue(null)
+
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({ error: 'No current workspace set. Run "auth extract" first.' }),
+  )
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})