agent-messenger 1.15.0 → 2.0.0

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

@@ -0,0 +1,162 @@
+import { describe, expect, test } from 'bun:test'
+
+import { LineClient } from './client'
+import { LineError } from './types'
+import type { LineChat, LineDevice, LineLoginResult, LineMessage, LineSendResult } from './types'
+
+describe('LineClient', () => {
+  test('constructor creates instance without errors', () => {
+    const client = new LineClient()
+    expect(client).toBeInstanceOf(LineClient)
+  })
+
+  test('constructor accepts a custom credential manager', () => {
+    const { LineCredentialManager } = require('./credential-manager')
+    const manager = new LineCredentialManager()
+    const client = new LineClient(manager)
+    expect(client).toBeInstanceOf(LineClient)
+  })
+
+  test('close() is idempotent - can be called multiple times without error', () => {
+    const client = new LineClient()
+    expect(() => client.close()).not.toThrow()
+    expect(() => client.close()).not.toThrow()
+    expect(() => client.close()).not.toThrow()
+  })
+
+  test('close() is idempotent after login attempt fails', async () => {
+    const client = new LineClient()
+    client.close()
+    client.close()
+  })
+
+  describe('ensureClient throws when not logged in', () => {
+    test('getChats() throws LineError with code not_connected', async () => {
+      const client = new LineClient()
+      await expect(client.getChats()).rejects.toThrow(LineError)
+      await expect(client.getChats()).rejects.toMatchObject({ code: 'not_connected' })
+    })
+
+    test('getMessages() throws LineError when not logged in', async () => {
+      const client = new LineClient()
+      await expect(client.getMessages('chat123')).rejects.toThrow(LineError)
+      await expect(client.getMessages('chat123')).rejects.toMatchObject({
+        code: 'not_connected',
+      })
+    })
+
+    test('sendMessage() throws LineError when not logged in', async () => {
+      const client = new LineClient()
+      await expect(client.sendMessage('chat123', 'hello')).rejects.toThrow(LineError)
+      await expect(client.sendMessage('chat123', 'hello')).rejects.toMatchObject({
+        code: 'not_connected',
+      })
+    })
+  })
+
+  describe('login() without credentials', () => {
+    test('throws LineError when no saved credentials exist', async () => {
+      const { LineCredentialManager } = require('./credential-manager')
+      const { mkdtemp } = require('node:fs/promises')
+      const { tmpdir } = require('node:os')
+      const { join } = require('node:path')
+
+      const dir = await mkdtemp(join(tmpdir(), 'line-test-'))
+      const manager = new LineCredentialManager(dir)
+      const client = new LineClient(manager)
+
+      await expect(client.login()).rejects.toThrow(LineError)
+      await expect(client.login()).rejects.toMatchObject({ code: 'not_authenticated' })
+    })
+  })
+
+  describe('LineError', () => {
+    test('LineError has correct name, code, and message', () => {
+      const err = new LineError('test_code', 'test message')
+      expect(err).toBeInstanceOf(Error)
+      expect(err).toBeInstanceOf(LineError)
+      expect(err.name).toBe('LineError')
+      expect(err.code).toBe('test_code')
+      expect(err.message).toBe('test message')
+    })
+
+    test('LineError is thrown by getChats and wraps the not_connected error', async () => {
+      const client = new LineClient()
+      try {
+        await client.getChats()
+        expect(true).toBe(false)
+      } catch (error) {
+        expect(error).toBeInstanceOf(LineError)
+        const lineError = error as LineError
+        expect(lineError.code).toBe('not_connected')
+        expect(lineError.message).toContain('Not connected')
+      }
+    })
+  })
+
+  describe('default device detection', () => {
+    test('LineClient can be instantiated (device detection does not throw)', () => {
+      expect(() => new LineClient()).not.toThrow()
+    })
+  })
+
+  describe('type exports', () => {
+    test('LineChat type is correctly shaped', () => {
+      const chat: LineChat = {
+        chat_id: 'c1234567890abcdef1234567890abcdef',
+        type: 'group',
+        display_name: 'My Group',
+        member_count: 5,
+      }
+      expect(chat.chat_id).toBe('c1234567890abcdef1234567890abcdef')
+      expect(chat.type).toBe('group')
+      expect(chat.display_name).toBe('My Group')
+      expect(chat.member_count).toBe(5)
+    })
+
+    test('LineMessage type is correctly shaped', () => {
+      const msg: LineMessage = {
+        message_id: 'msg123',
+        chat_id: 'chat456',
+        author_id: 'u1234567890abcdef1234567890abcdef',
+        text: 'Hello',
+        content_type: 'NONE',
+        sent_at: new Date().toISOString(),
+      }
+      expect(msg.message_id).toBe('msg123')
+      expect(msg.text).toBe('Hello')
+    })
+
+    test('LineMessage text can be null', () => {
+      const msg: LineMessage = {
+        message_id: 'msg123',
+        chat_id: 'chat456',
+        author_id: 'u1234567890abcdef1234567890abcdef',
+        text: null,
+        content_type: 'IMAGE',
+        sent_at: new Date().toISOString(),
+      }
+      expect(msg.text).toBeNull()
+    })
+
+    test('LineSendResult type is correctly shaped', () => {
+      const result: LineSendResult = {
+        success: true,
+        chat_id: 'chat456',
+        message_id: 'msg789',
+        sent_at: new Date().toISOString(),
+      }
+      expect(result.success).toBe(true)
+    })
+
+    test('LineLoginResult type is correctly shaped', () => {
+      const result: LineLoginResult = {
+        authenticated: true,
+        account_id: 'u1234567890abcdef1234567890abcdef',
+        display_name: 'Test User',
+        device: 'DESKTOPMAC' as LineDevice,
+      }
+      expect(result.authenticated).toBe(true)
+    })
+  })
+})

package/src/platforms/line/client.ts

@@ -0,0 +1,352 @@
+import { mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  loginWithQR as linejsLoginWithQR,
+  loginWithPassword as linejsLoginWithPassword,
+  loginWithAuthToken as linejsLoginWithAuthToken,
+  type Client,
+} from '@evex/linejs'
+import { FileStorage } from '@evex/linejs/storage'
+
+import { LineCredentialManager } from './credential-manager'
+import type {
+  LineAccountCredentials,
+  LineChat,
+  LineDevice,
+  LineFriend,
+  LineLoginResult,
+  LineMessage,
+  LineProfile,
+  LineSendResult,
+} from './types'
+import { LineError } from './types'
+
+function wrapError(error: unknown, code: string): LineError {
+  if (error instanceof LineError) return error
+  const message = error instanceof Error ? error.message : String(error)
+  return new LineError(code, message)
+}
+
+function mapChatType(rawType: unknown): 'user' | 'group' | 'room' | 'square' {
+  if (rawType === 'GROUP' || rawType === 0) return 'group'
+  if (rawType === 'ROOM' || rawType === 1) return 'room'
+  if (rawType === 'PEER' || rawType === 2) return 'user'
+  return 'square'
+}
+
+function getDefaultDevice(): LineDevice {
+  return 'ANDROIDSECONDARY'
+}
+
+function createStorage(accountId?: string): FileStorage {
+  const dir = join(homedir(), '.config', 'agent-messenger', 'line-storage')
+  mkdirSync(dir, { recursive: true })
+  return new FileStorage(join(dir, `${accountId ?? 'default'}.json`))
+}
+
+export class LineClient {
+  private client: Client | null = null
+  private credManager: LineCredentialManager
+
+  constructor(credManager?: LineCredentialManager) {
+    this.credManager = credManager ?? new LineCredentialManager()
+  }
+
+  async loginWithQR(options: {
+    device?: LineDevice
+    onQRUrl: (url: string) => void
+    onPincode: (pin: string) => void
+  }): Promise<LineLoginResult> {
+    try {
+      const device: LineDevice = options.device ?? getDefaultDevice()
+      const storage = createStorage()
+
+      const client = await linejsLoginWithQR(
+        {
+          onReceiveQRUrl: (url) => options.onQRUrl(url),
+          onPincodeRequest: (pin) => options.onPincode(pin),
+        },
+        { device, storage },
+      )
+
+      this.client = client
+
+      const profile = await client.base.talk.getProfile()
+      const now = new Date().toISOString()
+
+      await this.credManager.setAccount({
+        account_id: profile.mid,
+        auth_token: client.authToken,
+        device,
+        display_name: profile.displayName,
+        created_at: now,
+        updated_at: now,
+      })
+
+      return {
+        authenticated: true,
+        account_id: profile.mid,
+        display_name: profile.displayName,
+        device,
+      }
+    } catch (error) {
+      throw wrapError(error, 'login_qr_failed')
+    }
+  }
+
+  async loginWithEmail(options: {
+    email: string
+    password: string
+    device?: LineDevice
+    onPincode: (pin: string) => void
+  }): Promise<LineLoginResult> {
+    try {
+      const device: LineDevice = options.device ?? getDefaultDevice()
+      const storage = createStorage()
+
+      const client = await linejsLoginWithPassword(
+        {
+          email: options.email,
+          password: options.password,
+          onPincodeRequest: (pin) => options.onPincode(pin),
+        },
+        { device, storage },
+      )
+
+      this.client = client
+
+      const profile = await client.base.talk.getProfile()
+      const now = new Date().toISOString()
+
+      await this.credManager.setAccount({
+        account_id: profile.mid,
+        auth_token: client.authToken,
+        device,
+        display_name: profile.displayName,
+        created_at: now,
+        updated_at: now,
+      })
+
+      return {
+        authenticated: true,
+        account_id: profile.mid,
+        display_name: profile.displayName,
+        device,
+      }
+    } catch (error) {
+      throw wrapError(error, 'login_email_failed')
+    }
+  }
+
+  async login(credentials?: LineAccountCredentials): Promise<this> {
+    try {
+      let creds = credentials
+      if (!creds) {
+        const account = await this.credManager.getAccount()
+        if (!account) {
+          throw new LineError(
+            'not_authenticated',
+            'No account found. Call loginWithQR() or loginWithEmail() first.',
+          )
+        }
+        creds = account
+      }
+
+      const device: LineDevice = creds.device ?? getDefaultDevice()
+      const storage = createStorage()
+
+      this.client = await linejsLoginWithAuthToken(creds.auth_token, { device, storage })
+      return this
+    } catch (error) {
+      throw wrapError(error, 'login_failed')
+    }
+  }
+
+  async getProfile(): Promise<LineProfile> {
+    try {
+      const profile = await this.ensureClient().base.talk.getProfile()
+      return {
+        mid: profile.mid,
+        display_name: profile.displayName,
+        status_message: profile.statusMessage || undefined,
+        picture_url: profile.picturePath
+          ? `https://profile.line-scdn.net${profile.picturePath}`
+          : undefined,
+      }
+    } catch (error) {
+      throw wrapError(error, 'get_profile_failed')
+    }
+  }
+
+  async getFriends(): Promise<LineFriend[]> {
+    try {
+      const client = this.ensureClient()
+      const friendMids = await client.base.talk.getAllContactIds()
+      if (!friendMids?.length) return []
+
+      const contacts = await client.base.talk.getContacts({ mids: friendMids })
+      return (contacts ?? []).map((contact) => ({
+        mid: contact.mid,
+        display_name: contact.displayName,
+        status_message: contact.statusMessage || undefined,
+        picture_url: contact.picturePath
+          ? `https://profile.line-scdn.net${contact.picturePath}`
+          : undefined,
+      }))
+    } catch (error) {
+      throw wrapError(error, 'get_friends_failed')
+    }
+  }
+
+  async getChats(options?: { limit?: number }): Promise<LineChat[]> {
+    try {
+      const client = this.ensureClient()
+      const raw = options?.limit ?? 50
+      const limit = Number.isFinite(raw) && raw > 0 ? raw : 50
+      const seen = new Set<string>()
+      const results: LineChat[] = []
+
+      const [boxes, joinedChats] = await Promise.all([
+        client.base.talk.getMessageBoxes({
+          messageBoxListRequest: {
+            messageBoxCountLimit: limit,
+            lastMessagesPerMessageBoxCount: 0,
+          },
+          syncReason: 'INTERNAL',
+        }),
+        client.fetchJoinedChats().catch(() => []),
+      ])
+
+      for (const chat of joinedChats) {
+        if (seen.has(chat.mid)) continue
+        seen.add(chat.mid)
+        const memberMids = chat.raw.extra?.groupExtra?.memberMids
+        results.push({
+          chat_id: chat.mid,
+          type: mapChatType(chat.raw.type),
+          display_name: chat.name,
+          member_count: memberMids ? Object.keys(memberMids).length : undefined,
+        })
+      }
+
+      const messageBoxes = boxes?.messageBoxes ?? []
+      const userMids = messageBoxes
+        .filter((box) => box.midType === 'USER' && !seen.has(box.id))
+        .map((box) => box.id)
+      const groupMids = messageBoxes
+        .filter((box) => box.midType !== 'USER' && !seen.has(box.id))
+        .map((box) => box.id)
+
+      const nameMap = new Map<string, { name: string; type: 'user' | 'group' | 'room' | 'square'; memberCount?: number }>()
+
+      if (userMids.length > 0) {
+        try {
+          const contacts = await client.base.talk.getContacts({ mids: userMids })
+          for (const c of contacts ?? []) {
+            nameMap.set(c.mid, { name: c.displayName, type: 'user' })
+          }
+        } catch {}
+      }
+
+      if (groupMids.length > 0) {
+        try {
+          const { chats } = await client.base.talk.getChats({ chatMids: groupMids })
+          for (const c of chats ?? []) {
+            const memberMids = c.extra?.groupExtra?.memberMids
+            nameMap.set(c.chatMid, {
+              name: c.chatName ?? c.chatMid,
+              type: mapChatType(c.type),
+              memberCount: memberMids ? Object.keys(memberMids).length : undefined,
+            })
+          }
+        } catch {}
+      }
+
+      for (const box of messageBoxes) {
+        if (seen.has(box.id)) continue
+        seen.add(box.id)
+        const info = nameMap.get(box.id)
+        results.push({
+          chat_id: box.id,
+          type: info?.type ?? (box.midType === 'USER' ? 'user' as const : 'group' as const),
+          display_name: info?.name ?? box.id,
+          member_count: info?.memberCount,
+        })
+      }
+
+      return results
+    } catch (error) {
+      throw wrapError(error, 'get_chats_failed')
+    }
+  }
+
+  async getMessages(chatId: string, options?: { count?: number }): Promise<LineMessage[]> {
+    try {
+      const client = this.ensureClient()
+      const count = options?.count ?? 20
+
+      const serverTime = await client.base.talk.getServerTime()
+      const rawMessages = await client.base.talk.getPreviousMessagesV2WithRequest({
+        request: {
+          messageBoxId: chatId,
+          endMessageId: {
+            deliveredTime: BigInt(serverTime),
+            messageId: BigInt(0),
+          },
+          messagesCount: count,
+        },
+      })
+
+      return (rawMessages ?? []).map((msg) => ({
+        message_id: String(msg.id),
+        chat_id: chatId,
+        author_id: String(msg.from ?? ''),
+        text: msg.text || null,
+        content_type: String(msg.contentType ?? 'NONE'),
+        sent_at: new Date(Number(msg.createdTime)).toISOString(),
+      }))
+    } catch (error) {
+      throw wrapError(error, 'get_messages_failed')
+    }
+  }
+
+  async sendMessage(chatId: string, text: string): Promise<LineSendResult> {
+    try {
+      const client = this.ensureClient()
+      let sent;
+
+      try {
+        sent = await client.base.talk.sendMessage({ to: chatId, text, e2ee: true })
+      } catch (e2eeError) {
+        const msg = e2eeError instanceof Error ? e2eeError.message : String(e2eeError)
+        if (msg.includes('E2EE') || msg.includes('e2ee') || msg.includes('KeyNotFound') || msg.includes('saveE2EE')) {
+          sent = await client.base.talk.sendMessage({ to: chatId, text, e2ee: false })
+        } else {
+          throw e2eeError
+        }
+      }
+
+      return {
+        success: true,
+        chat_id: chatId,
+        message_id: String(sent.id),
+        sent_at: new Date(Number(sent.createdTime)).toISOString(),
+      }
+    } catch (error) {
+      throw wrapError(error, 'send_message_failed')
+    }
+  }
+
+  close(): void {
+    this.client = null
+  }
+
+  private ensureClient(): Client {
+    if (!this.client) {
+      throw new LineError('not_connected', 'Not connected. Call login() first.')
+    }
+    return this.client
+  }
+}