agent-messenger 2.2.0 → 2.4.0

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

@@ -0,0 +1,127 @@
+import { afterAll, 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 = {}
+  }
+}
+
+afterAll(() => {
+  mock.restore()
+})
+
+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/message.test.ts

@@ -0,0 +1,178 @@
+import { afterAll, 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 = {}
+  }
+}
+
+afterAll(() => {
+  mock.restore()
+})
+
+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/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, profileCommand } 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(profileCommand)
 
 program.parse(process.argv)
 

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

@@ -146,6 +146,68 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    test('falls back to LCHATLIST when login snapshot is empty (new device)', async () => {
+      // given — LOGINLIST returns empty chatDatas with eof:true (new device scenario)
+      const emptyLoginResult = {
+        chatDatas: [],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(emptyLoginResult)
+
+      mockGetChatList.mockResolvedValueOnce({
+        body: {
+          chatDatas: [
+            {
+              c: 100,
+              t: 1,
+              k: ['Alice', 'Bob'],
+              a: 2,
+              n: 3,
+              o: 1700000000,
+              l: { authorId: 1, message: 'hi', sendAt: 1700000000 },
+              ll: makeLong(999),
+            },
+            {
+              c: 200,
+              t: 2,
+              k: ['Charlie'],
+              a: 1,
+              n: 0,
+              o: 1699999000,
+              l: null,
+              ll: makeLong(500),
+            },
+          ],
+          lastTokenId: makeLong(1),
+          lastChatId: makeLong(200),
+          eof: true,
+        },
+      })
+
+      // when — default chat list (no --all flag)
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats()
+
+      // then — fetched via LCHATLIST despite eof:true and no --all
+      expect(chats).toHaveLength(2)
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+      expect(chats[0].display_name).toBe('Alice, Bob')
+      expect(chats[1].display_name).toBe('Charlie')
+
+      client.close()
+    })
+
+    test('does not call LCHATLIST when login snapshot has chats', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      await client.getChats()
+
+      expect(mockGetChatList).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
     test('paginates when all=true and not eof', async () => {
       const loginResult = {
         ...DEFAULT_LOGIN_RESULT,
@@ -384,6 +446,101 @@ describe('KakaoTalkClient', () => {
     })
   })
 
+  describe('getProfile', () => {
+    const mockFetch = mock(() => Promise.resolve(new Response()))
+
+    beforeEach(() => {
+      mockFetch.mockReset()
+      globalThis.fetch = mockFetch as unknown as typeof fetch
+    })
+
+    afterEach(() => {
+      mockFetch.mockReset()
+    })
+
+    function makeJsonResponse(data: unknown, status = 200): Response {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    test('returns profile data on success', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({
+          profile: {
+            nickName: 'Test User',
+            profileImageUrl: 'https://example.com/profile.jpg',
+            originalProfileImageUrl: 'https://example.com/original.jpg',
+            statusMessage: 'Hello world',
+          },
+        }))
+        .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: 'testuser123' }))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const profile = await client.getProfile()
+
+      expect(profile.user_id).toBe('user42')
+      expect(profile.nickname).toBe('Test User')
+      expect(profile.profile_image_url).toBe('https://example.com/profile.jpg')
+      expect(profile.original_profile_image_url).toBe('https://example.com/original.jpg')
+      expect(profile.status_message).toBe('Hello world')
+      expect(profile.account_display_id).toBe('testuser123')
+
+      client.close()
+    })
+
+    test('throws not_authenticated when not logged in', async () => {
+      const client = new KakaoTalkClient()
+      try {
+        await client.getProfile()
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('not_authenticated')
+      }
+    })
+
+    test('throws profile_request_failed when profile HTTP request fails', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({}, 401))
+        .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: null }))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      try {
+        await client.getProfile()
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('profile_request_failed')
+      }
+
+      client.close()
+    })
+
+    test('returns null account_display_id when more_settings request fails', async () => {
+      mockFetch
+        .mockResolvedValueOnce(makeJsonResponse({
+          profile: {
+            nickName: 'Test User',
+            profileImageUrl: null,
+            originalProfileImageUrl: null,
+            statusMessage: null,
+          },
+        }))
+        .mockResolvedValueOnce(makeJsonResponse({}, 500))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const profile = await client.getProfile()
+
+      expect(profile.user_id).toBe('user42')
+      expect(profile.nickname).toBe('Test User')
+      expect(profile.account_display_id).toBeNull()
+
+      client.close()
+    })
+  })
+
   describe('session lifecycle', () => {
     test('lazy init: does not call login until first method call', async () => {
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })

package/src/platforms/kakaotalk/client.ts

@@ -2,9 +2,10 @@ import { Long } from 'bson'
 
 import { warn } from '@/shared/utils/stderr'
 
+import { APP_VERSION, LANG, OS } from './protocol/config'
 import { LocoSession } from './protocol/session'
 import type { ChatListResponse, LoginListResponse } from './protocol/types'
-import type { KakaoChat, KakaoMessage, KakaoSendResult } from './types'
+import type { KakaoChat, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
 
 export class KakaoTalkError extends Error {
   code: string
@@ -206,11 +207,22 @@ export class KakaoTalkClient {
 
         collectChats((loginResult.chatDatas ?? []) as ChatData[], allChats, seenChatIds)
 
-        if (options?.all || options?.search) {
+        // Paginate via LCHATLIST when explicitly requested (--all / --search) OR when
+        // the login snapshot is empty. New device registrations often return an empty
+        // chatDatas with eof=true because the server has no prior sync state for the
+        // device — LCHATLIST fetches the canonical chat list regardless of device history.
+        const snapshotEmpty = allChats.length === 0
+        if (options?.all || options?.search || snapshotEmpty) {
           let cursor: ChatListResponse = loginResult
           let pages = 0
 
-          while (!cursor.eof && pages < MAX_PAGES) {
+          while (pages < MAX_PAGES) {
+            // Trust eof only when the snapshot had data. When the snapshot was empty
+            // (new device), ignore eof for the first iteration so we always attempt
+            // at least one LCHATLIST call.
+            if (cursor.eof && !snapshotEmpty) break
+            if (cursor.eof && snapshotEmpty && pages > 0) break
+
             const lastTokenId = bsonToLong(cursor.lastTokenId)
             const lastChatId = bsonToLong(cursor.lastChatId)
 
@@ -317,6 +329,48 @@ export class KakaoTalkClient {
     })
   }
 
+  async getProfile(): Promise<KakaoProfile> {
+    this.ensureAuth()
+    try {
+      const headers = {
+        Authorization: `${this.oauthToken}-${this.deviceUuid}`,
+        A: `${OS}/${APP_VERSION}/${LANG}`,
+        'User-Agent': `KT/${APP_VERSION} Md/macOS ${LANG}`,
+        Accept: '*/*',
+        'Accept-Language': LANG,
+      }
+
+      const [profileRes, settingsRes] = await Promise.all([
+        fetch('https://katalk.kakao.com/mac/profile3/me.json', { headers }),
+        fetch('https://katalk.kakao.com/mac/account/more_settings.json?since=0&lang=ko', { headers }),
+      ])
+
+      if (!profileRes.ok) {
+        throw new KakaoTalkError(`Profile request failed: ${profileRes.status}`, 'profile_request_failed')
+      }
+
+      const profileData = await profileRes.json() as Record<string, unknown>
+      const profile = profileData.profile as Record<string, unknown> | undefined
+
+      let accountDisplayId: string | null = null
+      if (settingsRes.ok) {
+        const settingsData = await settingsRes.json() as Record<string, unknown>
+        accountDisplayId = (settingsData.accountDisplayId as string) || null
+      }
+
+      return {
+        user_id: this.userId!,
+        nickname: (profile?.nickName as string) || '',
+        profile_image_url: (profile?.profileImageUrl as string) || null,
+        original_profile_image_url: (profile?.originalProfileImageUrl as string) || null,
+        status_message: (profile?.statusMessage as string) || null,
+        account_display_id: accountDisplayId,
+      }
+    } catch (error) {
+      throw wrapError(error, 'get_profile_failed')
+    }
+  }
+
   close(): void {
     this.closed = true
     if (this.state) {