agent-messenger 2.2.0 → 2.4.0

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

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineCredentialManager } from '../credential-manager'
+import { authCommand } from './auth'
+
+let getAccountSpy: ReturnType<typeof spyOn>
+let listAccountsSpy: ReturnType<typeof spyOn>
+let setCurrentAccountSpy: ReturnType<typeof spyOn>
+let removeAccountSpy: ReturnType<typeof spyOn>
+let clearAllSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  getAccountSpy = spyOn(LineCredentialManager.prototype, 'getAccount').mockResolvedValue({
+    account_id: 'u123',
+    auth_token: 'token-abc',
+    device: 'ANDROIDSECONDARY',
+    display_name: 'Test User',
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  })
+
+  listAccountsSpy = spyOn(LineCredentialManager.prototype, 'listAccounts').mockResolvedValue([
+    {
+      account_id: 'u123',
+      display_name: 'Test User',
+      device: 'ANDROIDSECONDARY',
+      is_current: true,
+      created_at: '2024-01-01T00:00:00Z',
+    },
+    {
+      account_id: 'u456',
+      display_name: 'Other User',
+      device: 'DESKTOPMAC',
+      is_current: false,
+      created_at: '2024-01-02T00:00:00Z',
+    },
+  ])
+
+  setCurrentAccountSpy = spyOn(LineCredentialManager.prototype, 'setCurrentAccount').mockResolvedValue(undefined)
+  removeAccountSpy = spyOn(LineCredentialManager.prototype, 'removeAccount').mockResolvedValue(undefined)
+  clearAllSpy = spyOn(LineCredentialManager.prototype, 'clearAll').mockResolvedValue(undefined)
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  getAccountSpy?.mockRestore()
+  listAccountsSpy?.mockRestore()
+  setCurrentAccountSpy?.mockRestore()
+  removeAccountSpy?.mockRestore()
+  clearAllSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('status: outputs account info when account exists', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'status'])
+
+  // then
+  expect(getAccountSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.account_id).toBe('u123')
+  expect(output.display_name).toBe('Test User')
+  expect(output.device).toBe('ANDROIDSECONDARY')
+})
+
+test('status: outputs error when no account configured', async () => {
+  // given
+  getAccountSpy.mockResolvedValue(null)
+
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'status'])
+
+  // then
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.error).toBe('No LINE account configured')
+})
+
+test('list: outputs all accounts', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'list'])
+
+  // then
+  expect(listAccountsSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].account_id).toBe('u123')
+  expect(output[1].account_id).toBe('u456')
+})
+
+test('list: outputs empty array when no accounts', async () => {
+  // given
+  listAccountsSpy.mockResolvedValue([])
+
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(0)
+})
+
+test('use: sets current account and outputs result', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'use', 'u456'])
+
+  // then
+  expect(setCurrentAccountSpy).toHaveBeenCalledWith('u456')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.current_account).toBe('u456')
+})
+
+test('logout: removes specific account when account-id provided', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'logout', 'u123'])
+
+  // then
+  expect(removeAccountSpy).toHaveBeenCalledWith('u123')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message).toContain('u123')
+})
+
+test('logout: clears all accounts when no account-id provided', async () => {
+  // when
+  await authCommand.parseAsync(['node', 'auth', 'logout'])
+
+  // then
+  expect(clearAllSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message).toBe('Logged out')
+})

package/src/platforms/line/commands/auth.ts

@@ -13,7 +13,6 @@ import { info } from '@/shared/utils/stderr'
 import { LineClient } from '../client'
 import { LineCredentialManager } from '../credential-manager'
 import type { LineDevice } from '../types'
-import { LINE_NEXT_ACTIONS } from '../types'
 
 function isInteractiveSession(): boolean {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY)
@@ -23,7 +22,7 @@ function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
 
-async function openQRInBrowser(url: string): Promise<void> {
+async function createQRHtmlFile(url: string): Promise<string> {
   const svgString = await QRCode.toString(url, { type: 'svg', margin: 2 })
   const html = `<!DOCTYPE html>
 <html><head><meta charset="utf-8"><title>LINE QR Login</title>
@@ -35,18 +34,20 @@ svg{width:280px;height:280px}</style></head>
 
   const htmlPath = join(tmpdir(), `line-qr-${Date.now()}.html`)
   writeFileSync(htmlPath, html)
+  setTimeout(() => { try { unlinkSync(htmlPath) } catch {} }, 300_000).unref()
+  return htmlPath
+}
 
+function openInBrowser(filePath: string): void {
   try {
     if (process.platform === 'darwin') {
-      execSync(`open "${htmlPath}"`, { stdio: 'ignore' })
+      execSync(`open "${filePath}"`, { stdio: 'ignore' })
     } else if (process.platform === 'win32') {
-      execSync(`start "" "${htmlPath}"`, { stdio: 'ignore' })
+      execSync(`start "" "${filePath}"`, { stdio: 'ignore' })
     } else {
-      execSync(`xdg-open "${htmlPath}"`, { stdio: 'ignore' })
+      execSync(`xdg-open "${filePath}"`, { stdio: 'ignore' })
     }
   } catch {}
-
-  setTimeout(() => { try { unlinkSync(htmlPath) } catch {} }, 30_000)
 }
 
 async function loginAction(options: {
@@ -94,21 +95,29 @@ async function loginAction(options: {
       })
       console.log(formatOutput(result, options.pretty))
     } else {
-      if (!interactive) {
-        console.log(formatOutput(LINE_NEXT_ACTIONS.run_interactive, options.pretty))
-        return
-      }
-
       const result = await client.loginWithQR({
         device,
         onQRUrl: async (url) => {
-          await openQRInBrowser(url).catch(() => {})
-          try {
-            const qrAscii = await QRCode.toString(url, { type: 'terminal', small: true })
-            info('\nScan this QR code with the LINE mobile app:\n')
-            info(qrAscii)
-          } catch {
-            info(`\nOpen the QR code in the browser window, or scan this URL:\n${url}\n`)
+          const htmlPath = await createQRHtmlFile(url).catch(() => null)
+          if (htmlPath) openInBrowser(htmlPath)
+
+          if (interactive) {
+            try {
+              const qrAscii = await QRCode.toString(url, { type: 'terminal', small: true })
+              info('\nScan this QR code with the LINE mobile app:\n')
+              info(qrAscii)
+            } catch {
+              info(`\nOpen the QR code in the browser window, or scan this URL:\n${url}\n`)
+            }
+          } else {
+            console.log(formatOutput({
+              next_action: 'scan_qr',
+              qr_url: url,
+              qr_html_path: htmlPath,
+              message: htmlPath
+                ? 'QR code opened in browser. Scan with LINE mobile app to complete login.'
+                : 'QR code generated. Open qr_url to scan with LINE mobile app.',
+            }, options.pretty))
           }
         },
         onPincode: (pin) => {

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

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { chatCommand } from './chat'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getChatsSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getChatsSpy = spyOn(LineClient.prototype, 'getChats').mockResolvedValue([
+    {
+      chat_id: 'c111',
+      type: 'user',
+      display_name: 'Alice',
+      member_count: 2,
+    },
+    {
+      chat_id: 'c222',
+      type: 'group',
+      display_name: 'Team Chat',
+      member_count: 10,
+    },
+    {
+      chat_id: 'c333',
+      type: 'room',
+      display_name: 'Project Room',
+      member_count: 5,
+    },
+  ])
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getChatsSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs chats', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 50 })
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(3)
+  expect(output[0].chat_id).toBe('c111')
+  expect(output[1].chat_id).toBe('c222')
+})
+
+test('list: uses default limit of 50 when no limit provided', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 50 })
+})
+
+test('list: uses custom limit when --limit option provided', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list', '--limit', '10'])
+
+  // then
+  expect(getChatsSpy).toHaveBeenCalledWith({ limit: 10 })
+})
+
+test('list: closes client after fetching chats', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs chat metadata', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const chat = output[0]
+  expect(chat.chat_id).toBeDefined()
+  expect(chat.type).toBeDefined()
+  expect(chat.display_name).toBeDefined()
+})
+
+test('list: includes different chat types', async () => {
+  // when
+  await chatCommand.parseAsync(['node', 'chat', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const types = output.map((c: { type: string }) => c.type)
+  expect(types).toContain('user')
+  expect(types).toContain('group')
+  expect(types).toContain('room')
+})

package/src/platforms/line/commands/friend.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { friendCommand } from './friend'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getFriendsSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getFriendsSpy = spyOn(LineClient.prototype, 'getFriends').mockResolvedValue([
+    {
+      mid: 'u111',
+      display_name: 'Alice',
+      picture_url: 'https://example.com/alice.jpg',
+      status_message: 'Hey!',
+    },
+    {
+      mid: 'u222',
+      display_name: 'Bob',
+      picture_url: 'https://example.com/bob.jpg',
+      status_message: 'Hello',
+    },
+  ])
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getFriendsSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs friends', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getFriendsSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].mid).toBe('u111')
+  expect(output[0].display_name).toBe('Alice')
+})
+
+test('list: outputs friends with metadata', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const friend = output[0]
+  expect(friend.mid).toBeDefined()
+  expect(friend.display_name).toBeDefined()
+})
+
+test('list: closes client after fetching friends', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs empty array when no friends', async () => {
+  // given
+  getFriendsSpy.mockResolvedValue([])
+
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(0)
+})
+
+test('list: includes all friend fields', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output[0].picture_url).toBe('https://example.com/alice.jpg')
+  expect(output[0].status_message).toBe('Hey!')
+  expect(output[1].display_name).toBe('Bob')
+})

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

@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { messageCommand } from './message'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getMessagesSpy: ReturnType<typeof spyOn>
+let sendMessageSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getMessagesSpy = spyOn(LineClient.prototype, 'getMessages').mockResolvedValue([
+    {
+      message_id: 'msg-1',
+      chat_id: 'chat-1',
+      author_id: 'u123',
+      text: 'Hello world',
+      content_type: 'NONE',
+      sent_at: '2024-01-01T10:00:00Z',
+    },
+    {
+      message_id: 'msg-2',
+      chat_id: 'chat-1',
+      author_id: 'u456',
+      text: 'Hi there',
+      content_type: 'NONE',
+      sent_at: '2024-01-01T09:00:00Z',
+    },
+  ])
+
+  sendMessageSpy = spyOn(LineClient.prototype, 'sendMessage').mockResolvedValue({
+    success: true,
+    chat_id: 'chat-1',
+    message_id: 'msg-new',
+    sent_at: '2024-01-01T11:00:00Z',
+  })
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getMessagesSpy?.mockRestore()
+  sendMessageSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs messages for a chat', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getMessagesSpy).toHaveBeenCalledWith('chat-1', { count: 20 })
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].message_id).toBe('msg-1')
+  expect(output[0].text).toBe('Hello world')
+})
+
+test('list: uses custom count when --count option provided', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1', '--count', '5'])
+
+  // then
+  expect(getMessagesSpy).toHaveBeenCalledWith('chat-1', { count: 5 })
+})
+
+test('list: closes client after fetching messages', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('send: sends message and outputs result', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'send', 'chat-1', 'Hello!'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(sendMessageSpy).toHaveBeenCalledWith('chat-1', 'Hello!')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message_id).toBe('msg-new')
+})
+
+test('send: closes client after sending message', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'send', 'chat-1', 'Hello!'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs messages with metadata', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const msg = output[0]
+  expect(msg.message_id).toBeDefined()
+  expect(msg.chat_id).toBeDefined()
+  expect(msg.author_id).toBeDefined()
+  expect(msg.sent_at).toBeDefined()
+})

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

@@ -0,0 +1,85 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { profileCommand } from './profile'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getProfileSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getProfileSpy = spyOn(LineClient.prototype, 'getProfile').mockResolvedValue({
+    mid: 'u1234567890abcdef',
+    display_name: 'Test User',
+    picture_url: 'https://example.com/pic.jpg',
+    status_message: 'Hello LINE!',
+  })
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getProfileSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('profile: fetches and outputs profile', async () => {
+  // when
+  await profileCommand.parseAsync(['node', 'profile'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getProfileSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.mid).toBe('u1234567890abcdef')
+  expect(output.display_name).toBe('Test User')
+})
+
+test('profile: outputs profile with all fields', async () => {
+  // when
+  await profileCommand.parseAsync(['node', 'profile'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.mid).toBeDefined()
+  expect(output.display_name).toBeDefined()
+  expect(output.picture_url).toBeDefined()
+  expect(output.status_message).toBeDefined()
+})
+
+test('profile: closes client after fetching profile', async () => {
+  // when
+  await profileCommand.parseAsync(['node', 'profile'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('profile: outputs profile with picture_url', async () => {
+  // when
+  await profileCommand.parseAsync(['node', 'profile'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.picture_url).toBe('https://example.com/pic.jpg')
+})
+
+test('profile: outputs profile with status_message', async () => {
+  // when
+  await profileCommand.parseAsync(['node', 'profile'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.status_message).toBe('Hello LINE!')
+})