agent-messenger 2.4.0 → 2.5.0

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/protocol/session.ts

@@ -14,7 +14,7 @@ import {
   PROTOCOL_VERSION,
 } from './config'
 import { LocoConnection } from './connection'
-import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket } from './types'
+import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket, SyncState } from './types'
 
 export class LocoSession {
   private connection: LocoConnection | null = null
@@ -22,7 +22,7 @@ export class LocoSession {
   private pushHandler: ((packet: LocoPacket) => void) | null = null
   private closeHandler: (() => void) | null = null
 
-  async login(oauthToken: string, userId: string, deviceUuid: string): Promise<LoginListResponse> {
+  async login(oauthToken: string, userId: string, deviceUuid: string, syncState?: SyncState): Promise<LoginListResponse> {
     const { host, port } = await this.bookAndCheckin(userId)
 
     this.connection = new LocoConnection()
@@ -35,6 +35,13 @@ export class LocoSession {
       this.connection.onClose(this.closeHandler)
     }
 
+    const chatIds = syncState?.chatIds.map((id) => new Long(id.low, id.high)) ?? []
+    const maxIds = syncState?.maxIds.map((id) => new Long(id.low, id.high)) ?? []
+    const lastTokenId = syncState
+      ? new Long(syncState.lastTokenId.low, syncState.lastTokenId.high)
+      : Long.fromNumber(0)
+    const lbk = syncState?.lbk ?? 0
+
     const response = await this.connection.sendPacket('LOGINLIST', {
       appVer: APP_VERSION,
       prtVer: PROTOCOL_VERSION,
@@ -45,11 +52,11 @@ export class LocoSession {
       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,
     })
@@ -117,6 +124,19 @@ export class LocoSession {
     })
   }
 
+  async getChatLogs(chatIds: Long[], sinces: Long[]): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('MCHATLOGS', {
+      chatIds,
+      sinces,
+    })
+  }
+
+  async getChatInfo(chatId: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('CHATONROOM', { chatId })
+  }
+
   async getChatList(lastTokenId?: Long, lastChatId?: Long): Promise<LocoPacket> {
     if (!this.connection) throw new Error('Not connected')
     return this.connection.sendPacket('LCHATLIST', {

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

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

package/src/platforms/kakaotalk/types.ts

@@ -130,8 +130,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 +145,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({

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)
+})