agent-messenger 2.3.0 → 2.5.0

package/src/platforms/instagram/client.ts

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

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

@@ -0,0 +1,216 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+import type { Command } from 'commander'
+
+const mockGetAccount = mock(() => Promise.resolve(null))
+const mockListAccounts = mock(() => Promise.resolve([]))
+const mockSetCurrent = mock(() => Promise.resolve(true))
+const mockRemoveAccount = mock(() => Promise.resolve(true))
+
+mock.module('../credential-manager', () => ({
+  InstagramCredentialManager: class {
+    getAccount = mockGetAccount
+    listAccounts = mockListAccounts
+    setCurrent = mockSetCurrent
+    removeAccount = mockRemoveAccount
+  },
+}))
+
+import { authCommand } from './auth'
+
+function resetCommandState(cmd: Command): void {
+  for (const sub of cmd.commands) {
+    (sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValues = {}
+    ;(sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValueSources = {}
+  }
+}
+
+describe('auth commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    resetCommandState(authCommand)
+
+    mockGetAccount.mockReset()
+    mockListAccounts.mockReset()
+    mockSetCurrent.mockReset()
+    mockRemoveAccount.mockReset()
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit called')
+    })
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+    processExitSpy.mockRestore()
+  })
+
+  describe('status', () => {
+    test('outputs error and exits when no account found', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['status'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('No Instagram account configured')
+    })
+
+    test('outputs account info when account exists', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'user_testuser',
+          username: 'testuser',
+          pk: '12345',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+
+      await authCommand.parseAsync(['status'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.account_id).toBe('user_testuser')
+      expect(output.username).toBe('testuser')
+      expect(output.pk).toBe('12345')
+    })
+
+    test('outputs error for specific account not found', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['status', '--account', 'missing_account'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('missing_account')
+    })
+  })
+
+  describe('list', () => {
+    test('outputs empty array when no accounts', async () => {
+      mockListAccounts.mockImplementation(() => Promise.resolve([]))
+
+      await authCommand.parseAsync(['list'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+
+    test('outputs accounts list', async () => {
+      mockListAccounts.mockImplementation(() =>
+        Promise.resolve([
+          {
+            account_id: 'user_alice',
+            username: 'alice',
+            pk: '111',
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+            is_current: true,
+          },
+          {
+            account_id: 'user_bob',
+            username: 'bob',
+            pk: '222',
+            created_at: '2024-01-02T00:00:00.000Z',
+            updated_at: '2024-01-02T00:00:00.000Z',
+            is_current: false,
+          },
+        ]),
+      )
+
+      await authCommand.parseAsync(['list'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(2)
+      expect(output[0].account_id).toBe('user_alice')
+      expect(output[0].is_current).toBe(true)
+      expect(output[1].account_id).toBe('user_bob')
+      expect(output[1].is_current).toBe(false)
+    })
+  })
+
+  describe('use', () => {
+    test('switches to specified account', async () => {
+      mockSetCurrent.mockImplementation(() => Promise.resolve(true))
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'user_alice',
+          username: 'alice',
+          pk: '111',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+
+      await authCommand.parseAsync(['use', 'user_alice'], { from: 'user' })
+
+      expect(mockSetCurrent).toHaveBeenCalledWith('user_alice')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.account_id).toBe('user_alice')
+    })
+
+    test('outputs error when account not found', async () => {
+      mockSetCurrent.mockImplementation(() => Promise.resolve(false))
+
+      await expect(
+        authCommand.parseAsync(['use', 'missing_account'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('missing_account')
+    })
+  })
+
+  describe('logout', () => {
+    test('removes account and outputs success', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'user_alice',
+          username: 'alice',
+          pk: '111',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+      mockRemoveAccount.mockImplementation(() => Promise.resolve(true))
+
+      await authCommand.parseAsync(['logout'], { from: 'user' })
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('user_alice')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.logged_out).toBe(true)
+      expect(output.account_id).toBe('user_alice')
+    })
+
+    test('outputs error when no account configured', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['logout'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('No Instagram account configured')
+    })
+
+    test('outputs error for specific account not found', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['logout', '--account', 'missing_account'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('missing_account')
+    })
+  })
+})

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

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+import type { Command } from 'commander'
+
+const mockListChats = mock(() =>
+  Promise.resolve([
+    { id: 'thread-1', title: 'Alice', last_message: 'Hi' },
+    { id: 'thread-2', title: 'Bob', last_message: 'Hey' },
+  ]),
+)
+
+const mockSearchChats = mock(() =>
+  Promise.resolve([{ id: 'thread-1', title: 'Alice', last_message: 'Hi' }]),
+)
+
+const mockClient = {
+  listChats: mockListChats,
+  searchChats: mockSearchChats,
+}
+
+mock.module('./shared', () => ({
+  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
+    return fn(mockClient)
+  },
+}))
+
+import { chatCommand } from './chat'
+
+function resetCommandState(cmd: Command): void {
+  for (const sub of cmd.commands) {
+    (sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValues = {}
+    ;(sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValueSources = {}
+  }
+}
+
+describe('chat commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    resetCommandState(chatCommand)
+
+    mockListChats.mockReset()
+    mockSearchChats.mockReset()
+
+    mockListChats.mockImplementation(() =>
+      Promise.resolve([
+        { id: 'thread-1', title: 'Alice', last_message: 'Hi' },
+        { id: 'thread-2', title: 'Bob', last_message: 'Hey' },
+      ]),
+    )
+    mockSearchChats.mockImplementation(() =>
+      Promise.resolve([{ id: 'thread-1', title: 'Alice', last_message: 'Hi' }]),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit called')
+    })
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+    processExitSpy.mockRestore()
+  })
+
+  describe('list', () => {
+    test('lists DM conversations', async () => {
+      await expect(
+        chatCommand.parseAsync(['list'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockListChats).toHaveBeenCalledWith(20)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(2)
+      expect(output[0].id).toBe('thread-1')
+      expect(output[1].id).toBe('thread-2')
+    })
+
+    test('passes custom limit', async () => {
+      await expect(
+        chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockListChats).toHaveBeenCalledWith(5)
+    })
+  })
+
+  describe('search', () => {
+    test('searches DM conversations by query', async () => {
+      await expect(
+        chatCommand.parseAsync(['search', 'Alice'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockSearchChats).toHaveBeenCalledWith('Alice', 20)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].id).toBe('thread-1')
+    })
+
+    test('passes custom limit to search', async () => {
+      await expect(
+        chatCommand.parseAsync(['search', 'Alice', '--limit', '10'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockSearchChats).toHaveBeenCalledWith('Alice', 10)
+    })
+
+    test('returns empty array when no results', async () => {
+      mockSearchChats.mockImplementation(() => Promise.resolve([]))
+
+      await expect(
+        chatCommand.parseAsync(['search', 'nobody'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+  })
+})

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

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

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

@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+import type { Command } from 'commander'
+
+const mockGetMessages = mock(() => Promise.resolve([{ id: 'msg-1', text: 'Hello' }]))
+const mockSendMessage = mock(() => Promise.resolve({ id: 'msg-2', text: 'Sent' }))
+const mockSendMessageToUser = mock(() => Promise.resolve({ id: 'msg-3', text: 'Sent to user' }))
+const mockSearchMessages = mock(() => Promise.resolve([{ id: 'msg-4', text: 'Found' }]))
+const mockSearchUsers = mock(() => Promise.resolve([{ pk: '999', username: 'targetuser' }]))
+
+const mockClient = {
+  getMessages: mockGetMessages,
+  sendMessage: mockSendMessage,
+  sendMessageToUser: mockSendMessageToUser,
+  searchMessages: mockSearchMessages,
+  searchUsers: mockSearchUsers,
+}
+
+mock.module('./shared', () => ({
+  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
+    return fn(mockClient)
+  },
+}))
+
+import { messageCommand } from './message'
+
+function resetCommandState(cmd: Command): void {
+  for (const sub of cmd.commands) {
+    (sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValues = {}
+    ;(sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValueSources = {}
+  }
+}
+
+describe('message commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    resetCommandState(messageCommand)
+
+    mockGetMessages.mockReset()
+    mockSendMessage.mockReset()
+    mockSendMessageToUser.mockReset()
+    mockSearchMessages.mockReset()
+    mockSearchUsers.mockReset()
+
+    mockGetMessages.mockImplementation(() => Promise.resolve([{ id: 'msg-1', text: 'Hello' }]))
+    mockSendMessage.mockImplementation(() => Promise.resolve({ id: 'msg-2', text: 'Sent' }))
+    mockSendMessageToUser.mockImplementation(() => Promise.resolve({ id: 'msg-3', text: 'Sent to user' }))
+    mockSearchMessages.mockImplementation(() => Promise.resolve([{ id: 'msg-4', text: 'Found' }]))
+    mockSearchUsers.mockImplementation(() => Promise.resolve([{ pk: '999', username: 'targetuser' }]))
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit called')
+    })
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+    processExitSpy.mockRestore()
+  })
+
+  describe('list', () => {
+    test('lists messages from a thread', async () => {
+      await expect(
+        messageCommand.parseAsync(['list', 'thread-123'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockGetMessages).toHaveBeenCalledWith('thread-123', 25)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([{ id: 'msg-1', text: 'Hello' }])
+    })
+
+    test('passes custom limit', async () => {
+      await expect(
+        messageCommand.parseAsync(['list', 'thread-123', '--limit', '10'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockGetMessages).toHaveBeenCalledWith('thread-123', 10)
+    })
+  })
+
+  describe('send', () => {
+    test('sends a message to a thread', async () => {
+      await expect(
+        messageCommand.parseAsync(['send', 'thread-123', 'Hello world'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockSendMessage).toHaveBeenCalledWith('thread-123', 'Hello world')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual({ id: 'msg-2', text: 'Sent' })
+    })
+  })
+
+  describe('send-to', () => {
+    test('sends a message to a user by username', async () => {
+      await expect(
+        messageCommand.parseAsync(['send-to', 'targetuser', 'Hi there'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockSearchUsers).toHaveBeenCalledWith('targetuser')
+      expect(mockSendMessageToUser).toHaveBeenCalledWith('999', 'Hi there')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual({ id: 'msg-3', text: 'Sent to user' })
+    })
+
+    test('strips @ prefix from username', async () => {
+      await expect(
+        messageCommand.parseAsync(['send-to', '@targetuser', 'Hi there'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockSearchUsers).toHaveBeenCalledWith('targetuser')
+    })
+
+    test('handles user not found error', async () => {
+      mockSearchUsers.mockImplementation(() => Promise.resolve([]))
+
+      try {
+        await messageCommand.parseAsync(['send-to', 'unknownuser', 'Hi'], { from: 'user' })
+      } catch {
+        /* empty */
+      }
+
+      expect(mockSendMessageToUser).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('search', () => {
+    test('searches messages by query', async () => {
+      await expect(
+        messageCommand.parseAsync(['search', 'hello'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockSearchMessages).toHaveBeenCalledWith('hello', { threadId: undefined, limit: 20 })
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([{ id: 'msg-4', text: 'Found' }])
+    })
+
+    test('passes thread option to search', async () => {
+      await expect(
+        messageCommand.parseAsync(['search', 'hello', '--thread', 'thread-456'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockSearchMessages).toHaveBeenCalledWith('hello', { threadId: 'thread-456', limit: 20 })
+    })
+
+    test('passes limit option to search', async () => {
+      await expect(
+        messageCommand.parseAsync(['search', 'hello2', '--limit', '5'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(mockSearchMessages).toHaveBeenCalledWith('hello2', { threadId: undefined, limit: 5 })
+    })
+  })
+
+  describe('search-users', () => {
+    test('searches users by query', async () => {
+      await expect(
+        messageCommand.parseAsync(['search-users', 'target'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockSearchUsers).toHaveBeenCalledWith('target')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([{ pk: '999', username: 'targetuser' }])
+    })
+  })
+})

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

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

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

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

package/src/platforms/kakaotalk/cli.ts

@@ -4,7 +4,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureKakaoAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -31,6 +31,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)