agent-messenger 2.12.2 → 2.13.0

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

@@ -7,6 +7,10 @@ const mockLogin = mock(() => Promise.resolve({}))
 const mockGetChatList = mock(() => Promise.resolve({}))
 const mockGetChatLogs = mock(() => Promise.resolve({}))
 const mockGetChatInfo = mock(() => Promise.resolve({}))
+const mockGetChannelInfo = mock(() => Promise.resolve({}))
+const mockGetOpenLinkInfo = mock(() => Promise.resolve({}))
+const mockGetAllMembers = mock(() => Promise.resolve({}))
+const mockGetMembersByIds = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
@@ -19,6 +23,10 @@ mock.module('./protocol/session', () => ({
     getChatList = mockGetChatList
     getChatLogs = mockGetChatLogs
     getChatInfo = mockGetChatInfo
+    getChannelInfo = mockGetChannelInfo
+    getOpenLinkInfo = mockGetOpenLinkInfo
+    getAllMembers = mockGetAllMembers
+    getMembersByIds = mockGetMembersByIds
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
     close = mockClose
@@ -36,6 +44,10 @@ function resetAllMocks() {
   mockGetChatList.mockReset()
   mockGetChatLogs.mockReset()
   mockGetChatInfo.mockReset()
+  mockGetChannelInfo.mockReset()
+  mockGetOpenLinkInfo.mockReset()
+  mockGetAllMembers.mockReset()
+  mockGetMembersByIds.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
   mockClose.mockReset()
@@ -43,13 +55,15 @@ function resetAllMocks() {
   mockOnPush.mockReset()
 }
 
-// LOCO protocol uses plain numbers for chat.c, but Long-like objects for logIds/cursors
+// LOCO protocol uses plain numbers for chat.c, but Long-like objects for logIds/cursors.
+// `i` and `k` are paired arrays — i[n] is the user_id, k[n] is the nickname.
 const DEFAULT_LOGIN_RESULT = {
   chatDatas: [
     {
       c: 100,
       t: 1,
       k: ['Alice', 'Bob'],
+      i: [1, 2],
       a: 2,
       n: 3,
       o: 1700000000,
@@ -60,6 +74,7 @@ const DEFAULT_LOGIN_RESULT = {
       c: 200,
       t: 2,
       k: ['Charlie'],
+      i: [3],
       a: 1,
       n: 0,
       o: 1699999000,
@@ -123,19 +138,248 @@ describe('KakaoTalkClient', () => {
 
       expect(chats).toHaveLength(2)
       expect(chats[0].display_name).toBe('Alice, Bob')
+      expect(chats[0].title).toBeNull()
       expect(chats[0].active_members).toBe(2)
       expect(chats[0].unread_count).toBe(3)
       expect(chats[0].last_message).toEqual({
         author_id: 1,
+        author_name: 'Alice',
         message: 'hi',
         sent_at: 1700000000,
       })
       expect(chats[1].display_name).toBe('Charlie')
+      expect(chats[1].title).toBeNull()
       expect(chats[1].last_message).toBeNull()
 
       client.close()
     })
 
+    it('populates last_message.author_name from paired chat.i / chat.k arrays', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats()
+
+      expect(chats[0].last_message?.author_name).toBe('Alice')
+    })
+
+    it('returns null author_name when authorId is not in the paired arrays', async () => {
+      const customLogin = {
+        ...DEFAULT_LOGIN_RESULT,
+        chatDatas: [
+          {
+            c: 100,
+            t: 1,
+            k: ['Alice'],
+            i: [1],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: { authorId: 99, message: 'from a stranger', sendAt: 1700000000 },
+            ll: makeLong(999),
+          },
+        ],
+      }
+      mockLogin.mockResolvedValue(customLogin)
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats()
+
+      expect(chats[0].last_message?.author_id).toBe(99)
+      expect(chats[0].last_message?.author_name).toBeNull()
+    })
+
+    it('returns null author_name when chat.i is missing (no paired data)', async () => {
+      const customLogin = {
+        ...DEFAULT_LOGIN_RESULT,
+        chatDatas: [
+          {
+            c: 100,
+            t: 1,
+            k: ['Alice'],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: { authorId: 1, message: 'hi', sendAt: 1700000000 },
+            ll: makeLong(999),
+          },
+        ],
+      }
+      mockLogin.mockResolvedValue(customLogin)
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats()
+
+      expect(chats[0].last_message?.author_name).toBeNull()
+    })
+
+    it('does not call CHATINFO when resolveTitles is not set (default behavior preserved)', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      await client.getChats()
+
+      expect(mockGetChannelInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('resolves user-set titles via CHATINFO when resolveTitles=true', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        body: {
+          chatInfo: {
+            chatMetas: [
+              { type: 1, content: '{"notice":"hello"}', revision: makeLong(1), updatedAt: 0 },
+              { type: 3, content: 'Renamed Chat', revision: makeLong(2), updatedAt: 0 },
+            ],
+          },
+        },
+      })
+      mockGetChannelInfo.mockResolvedValueOnce({
+        body: {
+          chatInfo: {
+            chatMetas: [],
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ resolveTitles: true })
+
+      expect(mockGetChannelInfo).toHaveBeenCalledTimes(2)
+      expect(chats[0].title).toBe('Renamed Chat')
+      expect(chats[0].display_name).toBe('Alice, Bob')
+      expect(chats[1].title).toBeNull()
+      expect(chats[1].display_name).toBe('Charlie')
+
+      client.close()
+    })
+
+    it('returns null title when chatInfo or chatMetas is missing', async () => {
+      mockGetChannelInfo.mockResolvedValue({ body: {} })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ resolveTitles: true })
+
+      for (const chat of chats) {
+        expect(chat.title).toBeNull()
+      }
+
+      client.close()
+    })
+
+    it('swallows CHATINFO failures and returns null title (does not poison list)', async () => {
+      mockGetChannelInfo.mockRejectedValueOnce(new Error('CHATINFO timed out'))
+      mockGetChannelInfo.mockResolvedValueOnce({
+        body: { chatInfo: { chatMetas: [{ type: 3, content: 'OK Title' }] } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ resolveTitles: true })
+
+      expect(chats).toHaveLength(2)
+      expect(chats[0].title).toBeNull()
+      expect(chats[1].title).toBe('OK Title')
+
+      client.close()
+    })
+
+    it('ignores empty-string title content and returns null', async () => {
+      mockGetChannelInfo.mockResolvedValue({
+        body: { chatInfo: { chatMetas: [{ type: 3, content: '' }] } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ resolveTitles: true })
+
+      for (const chat of chats) {
+        expect(chat.title).toBeNull()
+      }
+
+      client.close()
+    })
+
+    it('resolves open-chat titles via INFOLINK fallback in batch resolveTitles=true path', async () => {
+      // Mixed login snapshot: regular chat (uses CHATINFO TITLE meta), open chat
+      // with TITLE meta (CHATINFO only), open chat without TITLE meta (CHATINFO
+      // empty + INFOLINK fallback). Verifies the batch path wires open-chat
+      // fallback correctly — previously only the single-chat getChatTitle()
+      // path was covered.
+      const mixedLogin = {
+        chatDatas: [
+          {
+            c: 100,
+            t: 1,
+            k: ['Alice'],
+            i: [1],
+            a: 1,
+            n: 0,
+            o: 1700000003,
+            l: null,
+            ll: makeLong(1),
+          },
+          {
+            c: 500,
+            t: 'OM',
+            li: makeLong(7777),
+            k: ['User1'],
+            i: [10],
+            a: 1,
+            n: 0,
+            o: 1700000002,
+            l: null,
+            ll: makeLong(2),
+          },
+          {
+            c: 600,
+            t: 'OD',
+            li: makeLong(8888),
+            k: ['User2'],
+            i: [20],
+            a: 1,
+            n: 0,
+            o: 1700000001,
+            l: null,
+            ll: makeLong(3),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(mixedLogin)
+
+      // CHATINFO is fired in parallel for all 3 chats; mock by chatId so order
+      // doesn't matter (Promise.all resolves in fire order, not array order).
+      mockGetChannelInfo.mockImplementation((chatId: { low: number; high: number }) => {
+        switch (chatId.low) {
+          case 100:
+            return Promise.resolve({ body: { chatInfo: { chatMetas: [{ type: 3, content: 'Regular Title' }] } } })
+          case 500:
+            return Promise.resolve({ body: { chatInfo: { chatMetas: [{ type: 3, content: 'Open With Title' }] } } })
+          case 600:
+            return Promise.resolve({ body: { chatInfo: { chatMetas: [] } } })
+          default:
+            return Promise.resolve({ body: {} })
+        }
+      })
+      mockGetOpenLinkInfo.mockResolvedValueOnce({ body: { ols: [{ ln: 'Open Link Name' }] } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ resolveTitles: true })
+
+      const byId = Object.fromEntries(chats.map((c) => [c.chat_id, c]))
+      expect(byId['100'].title).toBe('Regular Title')
+      expect(byId['500'].title).toBe('Open With Title')
+      expect(byId['600'].title).toBe('Open Link Name')
+
+      // INFOLINK fires only for the open chat that lacked a TITLE meta — not
+      // for the regular chat (skipped by isOpenChat) and not for the open
+      // chat that already had a TITLE (skipped by short-circuit).
+      expect(mockGetOpenLinkInfo).toHaveBeenCalledTimes(1)
+      const [linkIds] = mockGetOpenLinkInfo.mock.calls[0] as [Array<{ low: number; high: number }>]
+      expect(linkIds).toHaveLength(1)
+      expect(linkIds[0]).toMatchObject({ low: 8888, high: 0 })
+
+      client.close()
+    })
+
     it('sorts chats by recency (o field descending)', async () => {
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
       const chats = await client.getChats()
@@ -307,6 +551,185 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('exposes getChatTitle() for single-chat title resolution', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        body: { chatInfo: { chatMetas: [{ type: 3, content: 'Direct Lookup' }] } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('100')
+
+      expect(title).toBe('Direct Lookup')
+      expect(mockGetChannelInfo).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
+    it('getChatTitle() returns null on CHATINFO failure', async () => {
+      mockGetChannelInfo.mockRejectedValueOnce(new Error('Network error'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('100')
+
+      expect(title).toBeNull()
+
+      client.close()
+    })
+
+    it('getChatTitle() returns null on invalid chatId without contacting LOCO', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('not-a-number')
+
+      expect(title).toBeNull()
+      expect(mockGetChannelInfo).not.toHaveBeenCalled()
+      expect(mockLogin).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('falls back to INFOLINK link name for open chats with no TITLE meta', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OM',
+            li: makeLong(7777),
+            k: ['User1', 'User2'],
+            i: [10, 20],
+            a: 2,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+      mockGetOpenLinkInfo.mockResolvedValueOnce({ body: { ols: [{ ln: 'Open Group Title' }] } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBe('Open Group Title')
+      expect(mockGetChannelInfo).toHaveBeenCalledTimes(1)
+      expect(mockGetOpenLinkInfo).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
+    it('does not call INFOLINK for non-open chats (regular MultiChat)', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('100')
+
+      expect(title).toBeNull()
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('does not call INFOLINK when CHATINFO already returned a TITLE meta', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OM',
+            li: makeLong(7777),
+            k: [],
+            i: [],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({
+        body: { chatInfo: { chatMetas: [{ type: 3, content: 'User Set Title' }] } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBe('User Set Title')
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('returns null when INFOLINK fails for open chats', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OD',
+            li: makeLong(7777),
+            k: [],
+            i: [],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+      mockGetOpenLinkInfo.mockRejectedValueOnce(new Error('INFOLINK timeout'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBeNull()
+
+      client.close()
+    })
+
+    it('returns null when open chat has no link id (li missing)', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OM',
+            k: [],
+            i: [],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBeNull()
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
     it('wraps getChatList failure as KakaoTalkError with code get_chats_failed', async () => {
       const loginResult = { ...DEFAULT_LOGIN_RESULT, eof: false }
       mockLogin.mockResolvedValue(loginResult)
@@ -346,6 +769,7 @@ describe('KakaoTalkClient', () => {
         log_id: '10',
         type: 1,
         author_id: 42,
+        author_name: null,
         message: 'hello',
         sent_at: 1700000001,
       })
@@ -353,6 +777,7 @@ describe('KakaoTalkClient', () => {
         log_id: '11',
         type: 1,
         author_id: 43,
+        author_name: null,
         message: 'world',
         sent_at: 1700000002,
       })
@@ -360,6 +785,31 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('resolves author_name for known members from the chat list cache', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: {
+          status: 0,
+          chatLogs: [
+            { logId: makeLong(1), chatId: 100, type: 1, authorId: 1, message: 'from Alice', sendAt: 100 },
+            { logId: makeLong(2), chatId: 100, type: 1, authorId: 2, message: 'from Bob', sendAt: 200 },
+            { logId: makeLong(3), chatId: 100, type: 1, authorId: 99, message: 'from a stranger', sendAt: 300 },
+          ],
+          eof: true,
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      // Trigger login so the cache is populated from DEFAULT_LOGIN_RESULT
+      await client.getChats()
+      const messages = await client.getMessages('100')
+
+      expect(messages[0].author_name).toBe('Alice')
+      expect(messages[1].author_name).toBe('Bob')
+      expect(messages[2].author_name).toBeNull()
+
+      client.close()
+    })
+
     it('respects count option', async () => {
       const logs = Array.from({ length: 50 }, (_, i) => ({
         logId: makeLong(i + 1),
@@ -460,6 +910,337 @@ describe('KakaoTalkClient', () => {
     })
   })
 
+  describe('getMembers / getMembersByIds', () => {
+    it('returns formatted members from GETMEM with normalized fields', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          members: [
+            {
+              userId: makeLong(42),
+              nickName: 'Alice',
+              type: 100,
+              profileImageUrl: 'https://kakao.com/p/alice.jpg',
+              fullProfileImageUrl: 'https://kakao.com/p/alice-full.jpg',
+              originalProfileImageUrl: 'https://kakao.com/p/alice-orig.jpg',
+              statusMessage: 'hi',
+              countryIso: 'KR',
+            },
+            {
+              userId: makeLong(43),
+              nickName: 'Bob',
+              type: 1000,
+              pi: 'https://kakao.com/p/bob.jpg',
+              fpi: 'https://kakao.com/p/bob-full.jpg',
+              opi: 'https://kakao.com/p/bob-orig.jpg',
+              opt: 12345,
+              pli: makeLong(99),
+              mt: 4,
+            },
+          ],
+          token: 0,
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembers('100')
+
+      expect(members).toHaveLength(2)
+      expect(members[0]).toEqual({
+        user_id: '42',
+        nickname: 'Alice',
+        profile_image_url: 'https://kakao.com/p/alice.jpg',
+        full_profile_image_url: 'https://kakao.com/p/alice-full.jpg',
+        original_profile_image_url: 'https://kakao.com/p/alice-orig.jpg',
+        status_message: 'hi',
+        country_iso: 'KR',
+        user_type: 100,
+        open_token: null,
+        open_profile_link_id: null,
+        open_permission: null,
+      })
+      expect(members[1]).toEqual({
+        user_id: '43',
+        nickname: 'Bob',
+        profile_image_url: 'https://kakao.com/p/bob.jpg',
+        full_profile_image_url: 'https://kakao.com/p/bob-full.jpg',
+        original_profile_image_url: 'https://kakao.com/p/bob-orig.jpg',
+        status_message: null,
+        country_iso: null,
+        user_type: 1000,
+        open_token: 12345,
+        open_profile_link_id: '99',
+        open_permission: 4,
+      })
+
+      client.close()
+    })
+
+    it('returns empty array when GETMEM returns no members', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({ statusCode: 0, body: {} })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembers('100')
+
+      expect(members).toEqual([])
+
+      client.close()
+    })
+
+    it('normalizes missing user_type to null and treats pli=0 as absent', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          members: [
+            { userId: makeLong(1), nickName: 'NoType' },
+            { userId: makeLong(2), nickName: 'ZeroPli', type: 1000, pli: makeLong(0) },
+            { userId: makeLong(3), nickName: 'NumericZeroPli', type: 1000, pli: 0 },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembers('100')
+
+      expect(members[0].user_type).toBeNull()
+      expect(members[0].open_profile_link_id).toBeNull()
+      expect(members[1].user_type).toBe(1000)
+      expect(members[1].open_profile_link_id).toBeNull()
+      expect(members[2].open_profile_link_id).toBeNull()
+
+      client.close()
+    })
+
+    it('wraps GETMEM failures as KakaoTalkError get_members_failed', async () => {
+      mockGetAllMembers.mockRejectedValueOnce(new Error('Network error'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembers('100')
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('throws on synthetic disconnect packet from GETMEM (statusCode != 0)', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: -1,
+        body: { error: 'connection closed' },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembers('100')
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('throws on GETMEM body.status nonzero', async () => {
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: -500 },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembers('100')
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('getMembersByIds passes parsed Long IDs to MEMBER request', async () => {
+      mockGetMembersByIds.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatId: makeLong(100),
+          members: [{ userId: makeLong(42), nickName: 'Alice', type: 100 }],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembersByIds('100', ['42', '43', '99'])
+
+      expect(members).toHaveLength(1)
+      expect(members[0].nickname).toBe('Alice')
+      expect(mockGetMembersByIds).toHaveBeenCalledTimes(1)
+
+      // Verify the actual LOCO call args, not just the call count: chatId is a
+      // Long-shaped { low, high } and memberIds is a list of Longs in the order
+      // the SDK consumer passed them. Guards against accidentally sending raw
+      // strings or losing IDs — both fail silently server-side.
+      const [chatIdArg, memberIdsArg] = mockGetMembersByIds.mock.calls[0] as [
+        { low: number; high: number },
+        Array<{ low: number; high: number }>,
+      ]
+      expect(chatIdArg).toMatchObject({ low: 100, high: 0 })
+      expect(memberIdsArg).toHaveLength(3)
+      expect(memberIdsArg[0]).toMatchObject({ low: 42, high: 0 })
+      expect(memberIdsArg[1]).toMatchObject({ low: 43, high: 0 })
+      expect(memberIdsArg[2]).toMatchObject({ low: 99, high: 0 })
+
+      client.close()
+    })
+
+    it('wraps MEMBER failures as KakaoTalkError get_members_failed', async () => {
+      mockGetMembersByIds.mockRejectedValueOnce(new Error('Network error'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembersByIds('100', ['42'])
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('throws on synthetic disconnect packet from MEMBER (statusCode != 0)', async () => {
+      mockGetMembersByIds.mockResolvedValueOnce({
+        statusCode: -1,
+        body: { error: 'connection closed' },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembersByIds('100', ['42'])
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('throws on MEMBER body.status nonzero', async () => {
+      mockGetMembersByIds.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: -500 },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembersByIds('100', ['42'])
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_members_failed')
+      }
+
+      client.close()
+    })
+
+    it('getMembers throws KakaoTalkError invalid_chat_id without contacting LOCO', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembers('not-a-number')
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_chat_id')
+      }
+      expect(mockGetAllMembers).not.toHaveBeenCalled()
+      expect(mockLogin).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('getMembersByIds throws invalid_chat_id for bad chatId without contacting LOCO', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembersByIds('not-a-number', ['42'])
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_chat_id')
+      }
+      expect(mockGetMembersByIds).not.toHaveBeenCalled()
+      expect(mockLogin).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('getMembersByIds throws invalid_user_id for bad userId without contacting LOCO', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getMembersByIds('100', ['42', 'bogus', '99'])
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_user_id')
+      }
+      expect(mockGetMembersByIds).not.toHaveBeenCalled()
+      expect(mockLogin).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('getMembersByIds returns [] without contacting LOCO when userIds is empty', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const result = await client.getMembersByIds('100', [])
+
+      expect(result).toEqual([])
+      expect(mockGetMembersByIds).not.toHaveBeenCalled()
+      expect(mockLogin).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('reconnects and retries getMembers after silent disconnect (full executeWithReconnect path)', async () => {
+      // Earlier tests verify assertLocoOk throws on a synthetic-disconnect packet,
+      // but they don't exercise the reconnect path: executeWithReconnect only
+      // retries when the underlying socket also closed (state.session !== this.state.session).
+      // This test fires the captured onClose callback before the rejection so the
+      // client's state is nulled, then verifies the operation is retried against
+      // a fresh session and the second response is returned to the caller.
+      const closeHandlers: Array<() => void> = []
+      mockOnClose.mockImplementation((handler: () => void) => {
+        closeHandlers.push(handler)
+      })
+
+      mockGetAllMembers.mockImplementationOnce(() => {
+        // Fire the close handler captured during the first session's setup —
+        // simulates the LOCO TCP socket closing while the GETMEM is in flight.
+        // executeWithReconnect sees state.session !== this.state.session and retries.
+        const handler = closeHandlers[0]
+        if (handler) handler()
+        return Promise.resolve({ statusCode: -1, body: { error: 'connection closed' } })
+      })
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { members: [{ userId: makeLong(42), nickName: 'Alice', type: 100 }] },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const members = await client.getMembers('100')
+
+      expect(members).toHaveLength(1)
+      expect(members[0].nickname).toBe('Alice')
+      expect(mockGetAllMembers).toHaveBeenCalledTimes(2)
+      // Login fires twice: once for the initial connect, once for the reconnect
+      // after the captured onClose handler invalidated this.state.
+      expect(mockLogin).toHaveBeenCalledTimes(2)
+
+      client.close()
+    })
+  })
+
   describe('getProfile', () => {
     const mockFetch = mock(() => Promise.resolve(new Response()))