agent-messenger 2.4.0 → 2.6.0

package/src/platforms/webex/commands/auth.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
 import * as childProcess from 'node:child_process'
 
 import { WebexClient } from '../client'
@@ -7,7 +7,9 @@ import { loginAction, logoutAction, statusAction } from './auth'
 
 describe('auth commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
-  let _consoleErrorSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
+  let execSpy: ReturnType<typeof spyOn>
+  const protoSpies: ReturnType<typeof spyOn>[] = []
   const mockPerson = {
     id: 'person-1',
     displayName: 'Test User',
@@ -17,21 +19,31 @@ describe('auth commands', () => {
     created: '2024-01-01T00:00:00.000Z',
   }
 
+  function protoSpy<T extends object>(target: T, method: keyof T) {
+    const s = spyOn(target, method as any)
+    protoSpies.push(s)
+    return s
+  }
+
   beforeEach(() => {
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
-    _consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
-    spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
+    execSpy = spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
   })
 
   afterEach(() => {
-    mock.restore()
+    consoleSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+    execSpy.mockRestore()
+    for (const s of protoSpies) s.mockRestore()
+    protoSpies.length = 0
   })
 
   describe('loginAction with --token', () => {
     test('authenticates with provided token (bot token flow)', async () => {
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
-      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
 
       await loginAction({ token: 'bot-token-123', pretty: false })
 
@@ -43,9 +55,9 @@ describe('auth commands', () => {
     })
 
     test('saves tokenType as manual with expiresAt 0', async () => {
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
-      const saveSpy = spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
 
       await loginAction({ token: 'bot-token-123', pretty: false })
 
@@ -58,7 +70,7 @@ describe('auth commands', () => {
 
   describe('loginAction with --client-id and --client-secret', () => {
     test('uses provided credentials for Device Grant flow', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -66,14 +78,14 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
         accessToken: 'at',
         refreshToken: 'rt',
         expiresAt: Date.now() + 3600000,
       })
-      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
@@ -82,7 +94,7 @@ describe('auth commands', () => {
     })
 
     test('saves tokenType as oauth in config', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -90,14 +102,14 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
         accessToken: 'at',
         refreshToken: 'rt',
         expiresAt: Date.now() + 3600000,
       })
-      const saveSpy = spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
@@ -106,7 +118,7 @@ describe('auth commands', () => {
     })
 
     test('saves clientId and clientSecret in config', async () => {
-      spyOn(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue({
         deviceCode: 'd',
         userCode: 'u',
         verificationUri: 'https://v',
@@ -114,18 +126,18 @@ describe('auth commands', () => {
         expiresIn: 300,
         interval: 0.01,
       })
-      spyOn(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken').mockResolvedValue({
         accessToken: 'at',
         refreshToken: 'rt',
         expiresAt: Date.now() + 3600000,
       })
-      spyOn(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      const saveSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await loginAction({ clientId: 'my-id', clientSecret: 'my-secret', pretty: false })
 
-      const savedConfig = (WebexCredentialManager.prototype.saveConfig as ReturnType<typeof spyOn>).mock.calls[0][0] as { clientId: string; clientSecret: string }
+      const savedConfig = saveSpy.mock.calls[0][0] as { clientId: string; clientSecret: string }
       expect(savedConfig.clientId).toBe('my-id')
       expect(savedConfig.clientSecret).toBe('my-secret')
     })
@@ -133,10 +145,10 @@ describe('auth commands', () => {
 
   describe('statusAction', () => {
     test('shows authenticated status when token is valid', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
-      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await statusAction({ pretty: false })
 
@@ -147,9 +159,9 @@ describe('auth commands', () => {
     })
 
     test('shows not authenticated when no token', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
-      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue(null)
-      const exitSpy = spyOn(process, 'exit').mockImplementation(() => undefined as never)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue(null)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
 
       await statusAction({ pretty: false })
 
@@ -160,10 +172,10 @@ describe('auth commands', () => {
     })
 
     test('shows not authenticated when token validation fails', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
-      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('invalid-token')
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('401 Unauthorized'))
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('invalid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('401 Unauthorized'))
 
       await statusAction({ pretty: false })
 
@@ -173,16 +185,16 @@ describe('auth commands', () => {
     })
 
     test('loads config for stored client credentials', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
         accessToken: 'at',
         refreshToken: 'rt',
         expiresAt: Date.now() + 3600000,
         clientId: 'stored-id',
         clientSecret: 'stored-secret',
       })
-      spyOn(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
-      spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
-      spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'getToken').mockResolvedValue('valid-token')
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
 
       await statusAction({ pretty: false })
 
@@ -192,12 +204,12 @@ describe('auth commands', () => {
 
   describe('logoutAction', () => {
     test('clears credentials when authenticated', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue({
         accessToken: 'token',
         refreshToken: 'refresh',
         expiresAt: Date.now() + 3600000,
       })
-      const clearSpy = spyOn(WebexCredentialManager.prototype, 'clearCredentials').mockResolvedValue(undefined)
+      const clearSpy = protoSpy(WebexCredentialManager.prototype, 'clearCredentials').mockResolvedValue(undefined)
 
       await logoutAction({ pretty: false })
 
@@ -208,8 +220,8 @@ describe('auth commands', () => {
     })
 
     test('shows error when not authenticated', async () => {
-      spyOn(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
-      const exitSpy = spyOn(process, 'exit').mockImplementation(() => undefined as never)
+      protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
 
       await logoutAction({ pretty: false })
 

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

@@ -3,3 +3,4 @@ export { memberCommand } from './member'
 export { messageCommand } from './message'
 export { snapshotAction, snapshotCommand } from './snapshot'
 export { spaceCommand } from './space'
+export { whoamiCommand } from './whoami'

package/src/platforms/webex/commands/member.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'
 
 import { WebexError } from '../types'
 
@@ -42,10 +42,6 @@ mock.module('../client', () => ({
 
 import { listAction } from './member'
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('member commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
 

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
 
 import { WebexError } from '../types'
 
@@ -56,10 +56,6 @@ mock.module('../client', () => ({
 
 import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
-afterAll(() => {
-  mock.restore()
-})
-
 let consoleLogSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {

package/src/platforms/webex/commands/message.ts

@@ -83,7 +83,7 @@ export async function deleteAction(
       console.log(
         formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty),
       )
-      process.exit(0)
+      return process.exit(0)
     }
 
     const client = await new WebexClient().login()

package/src/platforms/webex/commands/snapshot.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'
 import { WebexError } from '../types'
 
 const mockHandleError = mock((err: Error) => {
@@ -41,10 +41,6 @@ mock.module('../client', () => ({
 
 import { snapshotAction } from './snapshot'
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('snapshot command', () => {
   let consoleSpy: ReturnType<typeof spyOn>
 

package/src/platforms/webex/commands/space.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'
 
 import { WebexError } from '../types'
 
@@ -54,10 +54,6 @@ mock.module('../client', () => ({
 
 import { infoAction, listAction } from './space'
 
-afterAll(() => {
-  mock.restore()
-})
-
 let consoleLogSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {

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

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import * as clientModule from '../client'
+import { WebexError } from '../types'
+import { whoamiCommand } from './whoami'
+
+const mockUser = {
+  id: 'person-123',
+  emails: ['test@example.com'],
+  displayName: 'Test User',
+  nickName: 'Testy',
+  firstName: 'Test',
+  lastName: 'User',
+  avatar: 'https://example.com/avatar.jpg',
+  orgId: 'org-123',
+  type: 'person' as const,
+  created: '2024-01-01T00:00:00.000Z',
+}
+
+const makeFakeClient = () => ({
+  login: async function (this: unknown) { return this },
+  testAuth: async () => mockUser,
+})
+
+let webexClientSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  webexClientSpy = spyOn(clientModule, 'WebexClient').mockImplementation(
+    makeFakeClient as unknown as typeof clientModule.WebexClient,
+  )
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  webexClientSpy?.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 calls testAuth and outputs user fields', async () => {
+  // given: authenticated webex user
+  // when: running whoami
+  await whoamiCommand.parseAsync([], { from: 'user' })
+
+  // then: outputs all expected fields
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'person-123',
+      emails: ['test@example.com'],
+      displayName: 'Test User',
+      nickName: 'Testy',
+      firstName: 'Test',
+      lastName: 'User',
+      avatar: 'https://example.com/avatar.jpg',
+      orgId: 'org-123',
+      type: 'person',
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when --pretty flag is passed', async () => {
+  // given: authenticated webex user
+  // when: running whoami with --pretty
+  await whoamiCommand.parseAsync(['--pretty'], { from: 'user' })
+
+  // then: output is pretty-printed
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'person-123',
+        emails: ['test@example.com'],
+        displayName: 'Test User',
+        nickName: 'Testy',
+        firstName: 'Test',
+        lastName: 'User',
+        avatar: 'https://example.com/avatar.jpg',
+        orgId: 'org-123',
+        type: 'person',
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with code 1 when not authenticated', async () => {
+  // given: no credentials
+  webexClientSpy.mockImplementation(() => ({
+    login: async () => { throw new WebexError('No Webex credentials found.', 'no_credentials') },
+    testAuth: async () => mockUser,
+  }) as unknown as clientModule.WebexClient)
+
+  // when: running whoami
+  await whoamiCommand.parseAsync([], { from: 'user' })
+
+  // then: process exits with code 1
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

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

@@ -0,0 +1,31 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { WebexClient } from '../client'
+
+export async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const client = await new WebexClient().login()
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      emails: user.emails,
+      displayName: user.displayName,
+      nickName: user.nickName,
+      firstName: user.firstName,
+      lastName: user.lastName,
+      avatar: user.avatar,
+      orgId: user.orgId,
+      type: user.type,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/webex/credential-manager.test.ts

@@ -16,7 +16,6 @@ describe('WebexCredentialManager', () => {
 
   afterEach(async () => {
     await rm(tempDir, { recursive: true, force: true })
-    mock.restore()
   })
 
   test('loadConfig returns null when no file exists', async () => {

package/src/platforms/wechatbot/cli.ts

@@ -3,7 +3,7 @@
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, messageCommand, templateCommand, userCommand } from './commands/index'
+import { authCommand, messageCommand, templateCommand, userCommand, whoamiCommand } from './commands/index'
 
 const program = new Command()
 
@@ -15,6 +15,7 @@ program
   .option('--account <id>', 'Account ID to use')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(messageCommand)
 program.addCommand(templateCommand)
 program.addCommand(userCommand)

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

@@ -2,3 +2,4 @@ export { authCommand } from './auth'
 export { messageCommand } from './message'
 export { templateCommand } from './template'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockVerifyCredentials = mock(() => Promise.resolve(true))
+
+mock.module('../client', () => ({
+  WeChatBotClient: class MockWeChatBotClient {
+    async login(_credentials?: { appId: string; appSecret: string }) {
+      return this
+    }
+    verifyCredentials = mockVerifyCredentials
+  },
+}))
+
+import { WeChatBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `wechatbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_WECHATBOT_APP_ID
+    delete process.env.E2E_WECHATBOT_APP_SECRET
+    mockVerifyCredentials.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns app_id, account_name, and verified status', async () => {
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'secret123',
+      account_name: 'Test Official Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.app_id).toBe('wx1234567890')
+    expect(result.account_name).toBe('Test Official Account')
+    expect(result.verified).toBe(true)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns info for specific --account', async () => {
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wxAAA',
+      app_secret: 'secretA',
+      account_name: 'Account A',
+    })
+    await manager.setCredentials({
+      app_id: 'wxBBB',
+      app_secret: 'secretB',
+      account_name: 'Account B',
+    })
+
+    const result = await whoamiAction({ account: 'wxAAA', _credManager: manager })
+
+    expect(result.app_id).toBe('wxAAA')
+    expect(result.account_name).toBe('Account A')
+    expect(result.verified).toBe(true)
+  })
+
+  test('returns verified false when credentials are invalid', async () => {
+    mockVerifyCredentials.mockImplementationOnce(() => Promise.resolve(false))
+
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'bad-secret',
+      account_name: 'Test Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.app_id).toBe('wx1234567890')
+    expect(result.verified).toBe(false)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns error when client throws', async () => {
+    mockVerifyCredentials.mockImplementationOnce(() => Promise.reject(new Error('Network error')))
+
+    const manager = new WeChatBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      app_id: 'wx1234567890',
+      app_secret: 'secret123',
+      account_name: 'Test Account',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('Network error')
+  })
+})

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

@@ -0,0 +1,43 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { WeChatBotCredentialManager } from '../credential-manager'
+import type { AccountOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  app_id?: string | null
+  account_name?: string | null
+  verified?: boolean
+  error?: string
+}
+
+export async function whoamiAction(options: AccountOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const verified = await client.verifyCredentials()
+    const credManager = options._credManager ?? new WeChatBotCredentialManager()
+    const creds = await credManager.getCredentials(options.account)
+    return {
+      app_id: creds?.app_id ?? null,
+      account_name: creds?.account_name ?? null,
+      verified,
+    }
+  } 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('--account <id>', 'Account ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: AccountOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })