agent-messenger 2.37.0 → 2.37.1

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

@@ -242,6 +242,42 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('preserves an unknown non-empty string type from the login snapshot', async () => {
+      mockLogin.mockResolvedValue({
+        ...DEFAULT_LOGIN_RESULT,
+        chatDatas: [{ ...DEFAULT_LOGIN_RESULT.chatDatas[0], t: 'FutureChat' }],
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChats()).resolves.toMatchObject([{ type: 'FutureChat' }])
+
+      client.close()
+    })
+
+    for (const invalidType of ['', true] as const) {
+      it(`rejects invalid ${JSON.stringify(invalidType)} type from the login snapshot`, async () => {
+        mockLogin.mockResolvedValue({
+          ...DEFAULT_LOGIN_RESULT,
+          chatDatas: [{ ...DEFAULT_LOGIN_RESULT.chatDatas[0], t: invalidType }],
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChats()).rejects.toMatchObject({ code: 'get_chats_failed' })
+
+        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()
@@ -500,7 +536,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(emptyLoginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 100,
@@ -559,7 +597,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(loginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 300,
@@ -596,7 +636,9 @@ describe('KakaoTalkClient', () => {
 
       // Return a chat with same ID as login result
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 100, // Same as first login chat
@@ -630,7 +672,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(loginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: makeLong(300),
@@ -662,6 +706,148 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('collects every LCHATLIST page until an explicit EOF', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 300,
+                t: 1,
+                k: ['Dave'],
+                i: [4],
+                a: 1,
+                n: 0,
+                o: 1698000000,
+                l: null,
+                ll: makeLong(100),
+              },
+            ],
+            lastTokenId: makeLong(1),
+            lastChatId: makeLong(300),
+            eof: false,
+          },
+        })
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 400,
+                t: 1,
+                k: ['Erin'],
+                i: [5],
+                a: 1,
+                n: 0,
+                o: 1697000000,
+                l: null,
+                ll: makeLong(90),
+              },
+            ],
+            lastTokenId: makeLong(2),
+            lastChatId: makeLong(400),
+            eof: true,
+          },
+        })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ all: true })
+
+      expect(chats.map((chat) => chat.chat_id)).toEqual(['100', '200', '300', '400'])
+      expect(mockGetChatList).toHaveBeenCalledTimes(2)
+
+      client.close()
+    })
+
+    it('fails closed when LCHATLIST has a nonzero response status', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        statusCode: 503,
+        body: { status: 0, chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: true },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({
+        code: 'get_chats_failed',
+        responseFailureKind: 'provider_rejection',
+        serverStatus: 503,
+      })
+
+      client.close()
+    })
+
+    it('fails closed on an empty non-EOF LCHATLIST page', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: 0, chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: false },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({ code: 'get_chats_failed' })
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
+    it('fails closed when LCHATLIST reaches the page cap without EOF', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      let page = 0
+      mockGetChatList.mockImplementation(async () => {
+        page++
+        return {
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 1000 + page,
+                t: 1,
+                k: [`Room ${page}`],
+                i: [1000 + page],
+                a: 1,
+                n: 0,
+                o: 1600000000 - page,
+                l: null,
+                ll: makeLong(page),
+              },
+            ],
+            lastTokenId: makeLong(page),
+            lastChatId: makeLong(1000 + page),
+            eof: false,
+          },
+        }
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({ code: 'get_chats_failed' })
+      expect(mockGetChatList).toHaveBeenCalledTimes(50)
+
+      client.close()
+    })
+
+    it('preserves non-all search compatibility on an empty non-EOF page', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        body: { chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: false },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ search: 'Alice' })
+
+      expect(chats.map((chat) => chat.chat_id)).toEqual(['100'])
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
     it('wraps errors as KakaoTalkError', async () => {
       mockLogin.mockRejectedValue(new Error('Connection refused'))
 
@@ -884,6 +1070,7 @@ describe('KakaoTalkClient', () => {
           chatInfo: {
             chatId: makeLong(300),
             type: 11,
+            left: false,
             activeMembersCount: 2,
             newMessageCount: 4,
             invalidNewMessageCount: false,
@@ -927,6 +1114,303 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('classifies an explicit CHATINFO header rejection without exposing response contents', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 403, body: {} })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'packet',
+        serverStatus: 403,
+      })
+
+      client.close()
+    })
+
+    it('classifies an explicit CHATINFO body rejection and preserves its numeric status', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 0, body: { status: -404 } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'body',
+        serverStatus: -404,
+      })
+
+      client.close()
+    })
+
+    it('does not expose rejected CHATINFO body contents through public error metadata', async () => {
+      const secretSentinel = 'secret-sentinel-do-not-emit'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: -404, secret: secretSentinel },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      const publicError = error as KakaoTalkError
+      expect(publicError).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'body',
+        serverStatus: -404,
+      })
+      expect(publicError.message).not.toContain(secretSentinel)
+      expect(JSON.stringify(publicError)).not.toContain(secretSentinel)
+      expect(JSON.stringify(publicError.cause)).not.toContain(secretSentinel)
+
+      client.close()
+    })
+
+    it('classifies synthetic connection-close status -1 as transient rather than provider rejection', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: -1, body: { error: 'connection closed' } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'synthetic_connection_close',
+        responseFailureKind: 'transient_or_unknown',
+        responseStatusSource: 'packet',
+        serverStatus: -1,
+      })
+
+      client.close()
+    })
+
+    it('does not classify status -1 with a nonmatching body as a synthetic connection close', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: -1, body: { error: 'provider rejected' } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'packet',
+        serverStatus: -1,
+      })
+
+      client.close()
+    })
+
+    it('classifies a thrown CHATINFO transport failure as transient or unknown', async () => {
+      const secretSentinel = 'secret-transport-body-do-not-emit'
+      mockGetChannelInfo.mockRejectedValueOnce(
+        Object.assign(new Error('socket unavailable'), { body: { secret: secretSentinel } }),
+      )
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+
+      client.close()
+    })
+
+    it('classifies a successful CHATINFO response without chatInfo as structurally absent', async () => {
+      const secretSentinel = 'secret-chat-body-do-not-emit'
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 0, body: { secret: secretSentinel } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+
+      client.close()
+    })
+
+    it('classifies a successful CHATINFO response with null chatInfo as structurally absent', async () => {
+      const secretSentinel = 'secret-null-chat-body-do-not-emit'
+      const chatIdSentinel = '987654321012345678'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { chatInfo: null, secret: secretSentinel },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat(chatIdSentinel)
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+      expect(serialized).not.toContain('chatId')
+      expect(serialized).not.toContain(chatIdSentinel)
+
+      client.close()
+    })
+
+    it('classifies exact CHATINFO left=true as structurally absent without exposing response contents', async () => {
+      const secretSentinel = 'secret-left-chat-body-do-not-emit'
+      const nativeChatIdSentinel = '987654321'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            left: true,
+            chatId: makeLong(Number(nativeChatIdSentinel)),
+            secret: secretSentinel,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat(nativeChatIdSentinel)
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const publicError = error as KakaoTalkError
+      const serialized = JSON.stringify(publicError)
+      expect(publicError.message).not.toContain(secretSentinel)
+      expect(publicError.message).not.toContain(nativeChatIdSentinel)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain(nativeChatIdSentinel)
+
+      client.close()
+    })
+
+    for (const [label, chatInfo] of [
+      ['mismatched chatId', { left: true, chatId: makeLong(301) }],
+      ['missing chatId', { left: true }],
+      ['invalid chatId', { left: true, chatId: { invalid: true } }],
+    ] as const) {
+      it(`does not classify CHATINFO left=true with ${label} as structurally absent`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: { chatInfo },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).rejects.toMatchObject({
+          code: 'get_chat_failed',
+          getChatFailureReason: 'transport_or_unknown',
+          responseFailureKind: 'transient_or_unknown',
+        })
+
+        client.close()
+      })
+    }
+
+    for (const [label, chatInfo] of [
+      ['left=false', { left: false }],
+      ['left missing', {}],
+      ['left nonboolean', { left: 'true' }],
+    ] as const) {
+      it(`does not classify malformed successful CHATINFO with ${label} as structurally absent`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: { chatInfo },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).rejects.toMatchObject({
+          code: 'get_chat_failed',
+          getChatFailureReason: 'transport_or_unknown',
+          responseFailureKind: 'transient_or_unknown',
+        })
+
+        client.close()
+      })
+    }
+
+    it('classifies malformed successful CHATINFO chatInfo as transport or unknown', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { chatInfo: { chatId: makeLong(300) } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+
+      client.close()
+    })
+
     for (const openChatType of ['OM', 'OD'] as const) {
       it(`preserves ${openChatType} and falls back to INFOLINK when CHATINFO has no title`, async () => {
         mockGetChannelInfo.mockResolvedValueOnce({
@@ -1011,13 +1495,55 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
-    it('rejects an unknown string CHATINFO type without contacting INFOLINK', async () => {
+    for (const normalChatType of ['DirectChat', 'MultiChat', 'PlusChat', 'MemoChat'] as const) {
+      it(`preserves donor-defined ${normalChatType} without contacting INFOLINK`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            chatInfo: {
+              chatId: makeLong(300),
+              type: normalChatType,
+              activeMembersCount: 2,
+              newMessageCount: 0,
+              invalidNewMessageCount: false,
+              lastLogId: makeLong(1),
+              lastSeenLogId: makeLong(0),
+              displayMembers: [],
+              chatMetas: [],
+              li: makeLong(7777),
+              pushAlert: true,
+            },
+          },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).resolves.toEqual({
+          chat_id: '300',
+          type: normalChatType,
+          display_name: null,
+          title: null,
+          active_members: 2,
+          unread_count: 0,
+          last_message: null,
+        })
+        expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+        client.close()
+      })
+    }
+
+    it('rejects an empty string CHATINFO type without contacting INFOLINK', async () => {
       mockGetChannelInfo.mockResolvedValueOnce({
         statusCode: 0,
         body: {
           chatInfo: {
             chatId: makeLong(300),
-            type: 'UNKNOWN',
+            type: '',
             activeMembersCount: 2,
             newMessageCount: 0,
             invalidNewMessageCount: false,
@@ -1025,7 +1551,6 @@ describe('KakaoTalkClient', () => {
             lastSeenLogId: makeLong(0),
             displayMembers: [],
             chatMetas: [],
-            li: makeLong(7777),
             pushAlert: true,
           },
         },
@@ -1037,7 +1562,50 @@ describe('KakaoTalkClient', () => {
         deviceUuid: 'device1',
       })
 
-      await expect(client.getChat('300')).rejects.toMatchObject({ code: 'get_chat_failed' })
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('preserves an unknown non-empty string CHATINFO type without contacting INFOLINK', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: 'UnknownChat',
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(1),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChat('300')).resolves.toEqual({
+        chat_id: '300',
+        type: 'UnknownChat',
+        display_name: null,
+        title: null,
+        active_members: 2,
+        unread_count: 0,
+        last_message: null,
+      })
       expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
 
       client.close()