agent-messenger 2.3.0 → 2.4.0

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

@@ -0,0 +1,299 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockLoad = mock(() =>
+  Promise.resolve({ current_account: null, accounts: {} }),
+)
+const mockGetAccount = mock(() => Promise.resolve(null))
+const mockListAccounts = mock(() => Promise.resolve([]))
+const mockSetAccount = mock(() => Promise.resolve())
+const mockSetCurrentAccount = mock(() => Promise.resolve())
+const mockRemoveAccount = mock(() => Promise.resolve())
+const mockLoadPendingLogin = mock(() => Promise.resolve(null))
+
+mock.module('../credential-manager', () => ({
+  CredentialManager: class {
+    load = mockLoad
+    getAccount = mockGetAccount
+    listAccounts = mockListAccounts
+    setAccount = mockSetAccount
+    setCurrentAccount = mockSetCurrentAccount
+    removeAccount = mockRemoveAccount
+    loadPendingLogin = mockLoadPendingLogin
+  },
+  KakaoCredentialManager: class {
+    load = mockLoad
+    getAccount = mockGetAccount
+    listAccounts = mockListAccounts
+    setAccount = mockSetAccount
+    setCurrentAccount = mockSetCurrentAccount
+    removeAccount = mockRemoveAccount
+    loadPendingLogin = mockLoadPendingLogin
+  },
+}))
+
+import { authCommand } from './auth'
+
+describe('auth commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockLoad.mockReset()
+    mockGetAccount.mockReset()
+    mockListAccounts.mockReset()
+    mockSetAccount.mockReset()
+    mockSetCurrentAccount.mockReset()
+    mockRemoveAccount.mockReset()
+    mockLoadPendingLogin.mockReset()
+
+    mockLoad.mockImplementation(() =>
+      Promise.resolve({ current_account: null, accounts: {} }),
+    )
+    mockGetAccount.mockImplementation(() => Promise.resolve(null))
+    mockListAccounts.mockImplementation(() => Promise.resolve([]))
+    mockSetAccount.mockImplementation(() => Promise.resolve())
+    mockSetCurrentAccount.mockImplementation(() => Promise.resolve())
+    mockRemoveAccount.mockImplementation(() => Promise.resolve())
+    mockLoadPendingLogin.mockImplementation(() => Promise.resolve(null))
+
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
+    processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+      throw new Error(`process.exit(${_code})`)
+    })
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+    processExitSpy?.mockRestore()
+  })
+
+  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 with is_current flag', async () => {
+      mockListAccounts.mockImplementation(() =>
+        Promise.resolve([
+          {
+            account_id: 'user-1',
+            user_id: 'user-1',
+            device_type: 'tablet',
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+            is_current: true,
+            oauth_token: 'token-1',
+            refresh_token: 'refresh-1',
+            device_uuid: 'uuid-1',
+          },
+          {
+            account_id: 'user-2',
+            user_id: 'user-2',
+            device_type: 'pc',
+            created_at: '2024-01-02T00:00:00.000Z',
+            updated_at: '2024-01-02T00:00:00.000Z',
+            is_current: false,
+            oauth_token: 'token-2',
+            refresh_token: 'refresh-2',
+            device_uuid: 'uuid-2',
+          },
+        ]),
+      )
+
+      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-1')
+      expect(output[0].is_current).toBe(true)
+      expect(output[1].account_id).toBe('user-2')
+      expect(output[1].is_current).toBe(false)
+    })
+  })
+
+  describe('use', () => {
+    test('switches to specified account', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'user-1',
+          user_id: 'user-1',
+          device_type: 'tablet',
+          oauth_token: 'token-1',
+          refresh_token: 'refresh-1',
+          device_uuid: 'uuid-1',
+          created_at: '2024-01-01T00:00:00.000Z',
+          updated_at: '2024-01-01T00:00:00.000Z',
+        }),
+      )
+
+      await authCommand.parseAsync(['use', 'user-1'], { from: 'user' })
+
+      expect(mockSetCurrentAccount).toHaveBeenCalledWith('user-1')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.account_id).toBe('user-1')
+    })
+
+    test('outputs error and exits when account not found', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' }),
+      ).rejects.toThrow('process.exit')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toContain('nonexistent')
+    })
+  })
+
+  describe('status', () => {
+    test('outputs error and exits when no account configured', async () => {
+      mockGetAccount.mockImplementation(() => Promise.resolve(null))
+
+      await expect(
+        authCommand.parseAsync(['status'], { from: 'user' }),
+      ).rejects.toThrow('process.exit')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toBeDefined()
+    })
+
+    test('outputs account info when account exists', async () => {
+      mockGetAccount.mockImplementation(() =>
+        Promise.resolve({
+          account_id: 'user-1',
+          user_id: 'user-1',
+          device_type: 'tablet',
+          oauth_token: 'token-1',
+          refresh_token: 'refresh-1',
+          device_uuid: 'uuid-1',
+          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-1')
+      expect(output.user_id).toBe('user-1')
+      expect(output.device_type).toBe('tablet')
+      expect(output.has_refresh_token).toBe(true)
+      expect(output.has_device_uuid).toBe(true)
+    })
+
+    test('outputs status for specific --account', async () => {
+      mockGetAccount.mockImplementation((id?: string) => {
+        if (id === 'user-2') {
+          return Promise.resolve({
+            account_id: 'user-2',
+            user_id: 'user-2',
+            device_type: 'pc',
+            oauth_token: 'token-2',
+            refresh_token: 'refresh-2',
+            device_uuid: 'uuid-2',
+            created_at: '2024-01-02T00:00:00.000Z',
+            updated_at: '2024-01-02T00:00:00.000Z',
+          })
+        }
+        return Promise.resolve(null)
+      })
+
+      await authCommand.parseAsync(['status', '--account', 'user-2'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.account_id).toBe('user-2')
+      expect(output.device_type).toBe('pc')
+    })
+  })
+
+  describe('logout', () => {
+    test('removes current account and outputs success', async () => {
+      mockLoad.mockImplementation(() =>
+        Promise.resolve({
+          current_account: 'user-1',
+          accounts: {
+            'user-1': {
+              account_id: 'user-1',
+              user_id: 'user-1',
+              device_type: 'tablet',
+              oauth_token: 'token-1',
+              refresh_token: 'refresh-1',
+              device_uuid: 'uuid-1',
+              created_at: '2024-01-01T00:00:00.000Z',
+              updated_at: '2024-01-01T00:00:00.000Z',
+            },
+          },
+        }),
+      )
+
+      await authCommand.parseAsync(['logout'], { from: 'user' })
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('user-1')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.removed).toBe('user-1')
+    })
+
+    test('removes specific account with --account flag', async () => {
+      mockLoad.mockImplementation(() =>
+        Promise.resolve({
+          current_account: 'user-1',
+          accounts: {
+            'user-1': {
+              account_id: 'user-1',
+              user_id: 'user-1',
+              device_type: 'tablet',
+              oauth_token: 'token-1',
+              refresh_token: 'refresh-1',
+              device_uuid: 'uuid-1',
+              created_at: '2024-01-01T00:00:00.000Z',
+              updated_at: '2024-01-01T00:00:00.000Z',
+            },
+            'user-2': {
+              account_id: 'user-2',
+              user_id: 'user-2',
+              device_type: 'pc',
+              oauth_token: 'token-2',
+              refresh_token: 'refresh-2',
+              device_uuid: 'uuid-2',
+              created_at: '2024-01-02T00:00:00.000Z',
+              updated_at: '2024-01-02T00:00:00.000Z',
+            },
+          },
+        }),
+      )
+
+      await authCommand.parseAsync(['logout', '--account', 'user-2'], { from: 'user' })
+
+      expect(mockRemoveAccount).toHaveBeenCalledWith('user-2')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.success).toBe(true)
+      expect(output.removed).toBe('user-2')
+    })
+
+    test('outputs error and exits when no account configured', async () => {
+      mockLoad.mockImplementation(() =>
+        Promise.resolve({ current_account: null, accounts: {} }),
+      )
+
+      await expect(
+        authCommand.parseAsync(['logout'], { from: 'user' }),
+      ).rejects.toThrow('process.exit')
+
+      expect(processExitSpy).toHaveBeenCalledWith(1)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.error).toBeDefined()
+    })
+  })
+})

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

@@ -0,0 +1,97 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockWithKakaoClient = mock(
+  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+    return fn(mockClient)
+  },
+)
+
+const mockGetChats = mock(() =>
+  Promise.resolve([
+    { chat_id: 'chat-1', name: 'General', type: 'group', member_count: 5 },
+    { chat_id: 'chat-2', name: 'Direct', type: 'direct', member_count: 2 },
+  ]),
+)
+
+const mockClient = {
+  getChats: mockGetChats,
+}
+
+mock.module('./shared', () => ({
+  withKakaoClient: mockWithKakaoClient,
+}))
+
+import { chatCommand } from './chat'
+
+describe('chat commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockWithKakaoClient.mockReset()
+    mockGetChats.mockReset()
+
+    mockWithKakaoClient.mockImplementation(
+      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+        return fn(mockClient)
+      },
+    )
+    mockGetChats.mockImplementation(() =>
+      Promise.resolve([
+        { chat_id: 'chat-1', name: 'General', type: 'group', member_count: 5 },
+        { chat_id: 'chat-2', name: 'Direct', type: 'direct', member_count: 2 },
+      ]),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  describe('list', () => {
+    test('lists chat rooms', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(mockGetChats).toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(2)
+      expect(output[0].chat_id).toBe('chat-1')
+      expect(output[0].name).toBe('General')
+    })
+
+    test('passes --search option to getChats', async () => {
+      await chatCommand.parseAsync(['list', '--search', 'General'], { from: 'user' })
+
+      const call = mockGetChats.mock.calls[0][0] as { all?: boolean; search?: string }
+      expect(call.search).toBe('General')
+    })
+
+    test('passes --all flag to getChats', async () => {
+      await chatCommand.parseAsync(['list', '--all'], { from: 'user' })
+
+      const call = mockGetChats.mock.calls[0][0] as { all?: boolean; search?: string }
+      expect(call.all).toBe(true)
+    })
+
+    test('passes account option to withKakaoClient', async () => {
+      await chatCommand.parseAsync(['list', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+
+    test('outputs empty array when no chats', async () => {
+      mockGetChats.mockImplementation(() => Promise.resolve([]))
+
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+  })
+})

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

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

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

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockWithKakaoClient = mock(
+  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+    return fn(mockClient)
+  },
+)
+
+const mockGetMessages = mock(() =>
+  Promise.resolve([
+    { log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 },
+  ]),
+)
+
+const mockSendMessage = mock(() =>
+  Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }),
+)
+
+const mockClient = {
+  getMessages: mockGetMessages,
+  sendMessage: mockSendMessage,
+}
+
+mock.module('./shared', () => ({
+  withKakaoClient: mockWithKakaoClient,
+}))
+
+import { messageCommand } from './message'
+
+describe('message commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockWithKakaoClient.mockReset()
+    mockGetMessages.mockReset()
+    mockSendMessage.mockReset()
+
+    mockWithKakaoClient.mockImplementation(
+      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+        return fn(mockClient)
+      },
+    )
+    mockGetMessages.mockImplementation(() =>
+      Promise.resolve([
+        { log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 },
+      ]),
+    )
+    mockSendMessage.mockImplementation(() =>
+      Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  describe('list', () => {
+    test('fetches messages for a chat room with default count', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--count', '20'], { from: 'user' })
+
+      expect(mockGetMessages).toHaveBeenCalledWith('chat-123', { count: 20, from: undefined })
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].log_id).toBe('1')
+      expect(output[0].message).toBe('Hello')
+    })
+
+    test('respects --count option', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--count', '5'], { from: 'user' })
+
+      expect(mockGetMessages).toHaveBeenCalledWith('chat-123', { count: 5, from: undefined })
+    })
+
+    test('respects --from option', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--count', '20', '--from', '999'], { from: 'user' })
+
+      expect(mockGetMessages).toHaveBeenCalledWith('chat-123', { count: 20, from: '999' })
+    })
+
+    test('passes account option to withKakaoClient', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--count', '20', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+  })
+
+  describe('send', () => {
+    test('sends a message to a chat room', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello world'], { from: 'user' })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'Hello world')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.log_id).toBe('2')
+      expect(output.message).toBe('Hi there')
+    })
+
+    test('passes account option to withKakaoClient', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hi', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+  })
+})

package/src/platforms/kakaotalk/commands/profile.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockWithKakaoClient = mock(
+  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+    return fn(mockClient)
+  },
+)
+
+const mockGetProfile = mock(() =>
+  Promise.resolve({
+    user_id: 'user-1',
+    nickname: 'Test User',
+    profile_image_url: 'https://example.com/avatar.jpg',
+  }),
+)
+
+const mockClient = {
+  getProfile: mockGetProfile,
+}
+
+mock.module('./shared', () => ({
+  withKakaoClient: mockWithKakaoClient,
+}))
+
+import { profileCommand } from './profile'
+
+describe('profile command', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockWithKakaoClient.mockReset()
+    mockGetProfile.mockReset()
+
+    mockWithKakaoClient.mockImplementation(
+      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+        return fn(mockClient)
+      },
+    )
+    mockGetProfile.mockImplementation(() =>
+      Promise.resolve({
+        user_id: 'user-1',
+        nickname: 'Test User',
+        profile_image_url: 'https://example.com/avatar.jpg',
+      }),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  test('outputs profile information', async () => {
+    await profileCommand.parseAsync([], { from: 'user' })
+
+    expect(mockGetProfile).toHaveBeenCalled()
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+    expect(output.user_id).toBe('user-1')
+    expect(output.nickname).toBe('Test User')
+    expect(output.profile_image_url).toBe('https://example.com/avatar.jpg')
+  })
+
+  test('passes account option to withKakaoClient', async () => {
+    await profileCommand.parseAsync(['--account', 'my-account'], { from: 'user' })
+
+    expect(mockWithKakaoClient).toHaveBeenCalledWith(
+      expect.objectContaining({ account: 'my-account' }),
+      expect.any(Function),
+    )
+  })
+
+  test('outputs profile with pretty flag', async () => {
+    await profileCommand.parseAsync(['--pretty'], { from: 'user' })
+
+    expect(mockGetProfile).toHaveBeenCalled()
+    const rawOutput = consoleLogSpy.mock.calls[0][0]
+    const output = JSON.parse(rawOutput)
+    expect(output.user_id).toBe('user-1')
+  })
+})

package/src/platforms/kakaotalk/commands/profile.ts

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

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

@@ -12,6 +12,7 @@ import {
   KakaoTalkListener,
   KakaoTalkPushMemberEventSchema,
   KakaoTalkPushMessageEventSchema,
+  KakaoProfileSchema,
   KakaoTalkPushReadEventSchema,
 } from '@/platforms/kakaotalk/index'
 
@@ -66,3 +67,7 @@ test('KakaoTalkPushMemberEventSchema is exported from barrel', () => {
 test('KakaoTalkPushReadEventSchema is exported from barrel', () => {
   expect(typeof KakaoTalkPushReadEventSchema.parse).toBe('function')
 })
+
+test('KakaoProfileSchema is exported from barrel', () => {
+  expect(typeof KakaoProfileSchema.parse).toBe('function')
+})

package/src/platforms/kakaotalk/index.ts

@@ -8,6 +8,7 @@ export type {
   KakaoConfig,
   KakaoDeviceType,
   KakaoMessage,
+  KakaoProfile,
   KakaoSendResult,
   KakaoTalkListenerEventMap,
   KakaoTalkPushEvent,
@@ -21,6 +22,7 @@ export {
   KakaoChatSchema,
   KakaoConfigSchema,
   KakaoMessageSchema,
+  KakaoProfileSchema,
   KakaoSendResultSchema,
   KakaoTalkPushMemberEventSchema,
   KakaoTalkPushMessageEventSchema,

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

@@ -7,6 +7,7 @@ import {
   CHECKIN_HOST,
   CHECKIN_PORT,
   COUNTRY_ISO,
+  DTYPE,
   LANG,
   MCCMNC,
   PING_INTERVAL_MS,
@@ -39,6 +40,7 @@ export class LocoSession {
       prtVer: PROTOCOL_VERSION,
       os: 'mac',
       lang: LANG,
+      dtype: DTYPE,
       duuid: deviceUuid,
       oauthToken,
       ntype: 0,

package/src/platforms/kakaotalk/types.ts

@@ -125,6 +125,24 @@ export const KakaoSendResultSchema = z.object({
   sent_at: z.number(),
 })
 
+export interface KakaoProfile {
+  user_id: string
+  nickname: string
+  profile_image_url: string | null
+  original_profile_image_url: string | null
+  status_message: string | null
+  account_display_id: string | null
+}
+
+export const KakaoProfileSchema = z.object({
+  user_id: z.string(),
+  nickname: z.string(),
+  profile_image_url: z.string().nullable(),
+  original_profile_image_url: z.string().nullable(),
+  status_message: z.string().nullable(),
+  account_display_id: z.string().nullable(),
+})
+
 export const KakaoAccountCredentialsSchema = z.object({
   account_id: z.string(),
   oauth_token: z.string(),