agent-messenger 2.19.5 → 2.20.0

package/src/platforms/line/e2ee-storage.ts

@@ -0,0 +1,119 @@
+export interface E2EEKeyStore {
+  get(key: string): Promise<unknown> | unknown
+  set(key: string, value: string): Promise<void> | void
+}
+
+export interface E2EEKeyData {
+  keyId: number | string
+  privKey: string
+  pubKey: string
+  e2eeVersion?: number
+}
+
+export type E2EEPublicKey = { keyId?: number | string } | ReadonlyArray<unknown>
+
+const SELF_KEY_PREFIX = 'e2eeKeys:'
+
+function selfKey(id: number | string): string {
+  return `${SELF_KEY_PREFIX}${id}`
+}
+
+function isE2EEKeyData(value: unknown): value is E2EEKeyData {
+  if (!value || typeof value !== 'object') return false
+  const data = value as Partial<E2EEKeyData>
+  return typeof data.privKey === 'string' && typeof data.pubKey === 'string'
+}
+
+function parseKeyData(raw: unknown): E2EEKeyData | null {
+  if (typeof raw !== 'string') return isE2EEKeyData(raw) ? raw : null
+  try {
+    const parsed: unknown = JSON.parse(raw)
+    return isE2EEKeyData(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+// The stored payload carries its own keyId. Requiring it to equal the slot it was
+// read from rejects entries mislabeled under an advertised keyId, so only a payload
+// genuinely belonging to that keyId is ever trusted.
+function keyDataMatchesSlot(data: E2EEKeyData, keyId: number | string): boolean {
+  return String(data.keyId) === String(keyId)
+}
+
+function keyIdOf(key: E2EEPublicKey): number | string | undefined {
+  if (Array.isArray(key)) {
+    const id = key[2]
+    return typeof id === 'number' || typeof id === 'string' ? id : undefined
+  }
+  const id = (key as { keyId?: number | string }).keyId
+  return typeof id === 'number' || typeof id === 'string' ? id : undefined
+}
+
+function advertisedKeyIds(keys: ReadonlyArray<E2EEPublicKey> | undefined): Array<number | string> {
+  if (!keys) return []
+  const ids: Array<number | string> = []
+  for (const key of keys) {
+    const id = keyIdOf(key)
+    if (id !== undefined) ids.push(id)
+  }
+  return ids
+}
+
+// Ensures the account's own self-key is addressable by MID for getE2EESelfKeyData,
+// which checks `e2eeKeys:<mid>` before falling back to a live Thrift channel. The
+// keyId-addressed entry is only trusted when the server advertises that exact keyId
+// for this account, so a contaminated store (another account's key copied in) can
+// never promote a foreign private key to this MID. Returns true when a self-key
+// becomes available under the MID.
+export async function ensureSelfKeyForMid(
+  storage: E2EEKeyStore,
+  mid: string,
+  advertisedKeys: ReadonlyArray<E2EEPublicKey> | undefined,
+): Promise<boolean> {
+  if (!mid) return false
+
+  const existing = parseKeyData(await storage.get(selfKey(mid)))
+  if (existing) return true
+
+  for (const keyId of advertisedKeyIds(advertisedKeys)) {
+    const candidate = parseKeyData(await storage.get(selfKey(keyId)))
+    if (candidate && keyDataMatchesSlot(candidate, keyId)) {
+      await storage.set(selfKey(mid), JSON.stringify(candidate))
+      return true
+    }
+  }
+
+  return false
+}
+
+// Copies only this account's E2EE key material out of a shared (default) store into
+// an isolated per-account store. Trust is anchored to the server-advertised keyIds
+// for `mid`, so foreign-account keys present in the shared store are never carried
+// over. Used right after a fresh login resolves the account MID.
+export async function migrateOwnE2EEKeys(
+  source: E2EEKeyStore,
+  target: E2EEKeyStore,
+  mid: string,
+  advertisedKeys: ReadonlyArray<E2EEPublicKey> | undefined,
+): Promise<number> {
+  if (!mid) return 0
+
+  let migrated = 0
+  const own = parseKeyData(await source.get(selfKey(mid)))
+  if (own) {
+    await target.set(selfKey(mid), JSON.stringify(own))
+    migrated++
+  }
+
+  for (const keyId of advertisedKeyIds(advertisedKeys)) {
+    const data = parseKeyData(await source.get(selfKey(keyId)))
+    if (!data || !keyDataMatchesSlot(data, keyId)) continue
+    await target.set(selfKey(keyId), JSON.stringify(data))
+    migrated++
+    const publicKey = await source.get(`e2eePublicKeys:${keyId}`)
+    if (typeof publicKey === 'string') await target.set(`e2eePublicKeys:${keyId}`, publicKey)
+  }
+
+  return migrated
+}

package/src/platforms/teams/cli.ts

@@ -7,6 +7,7 @@ import pkg from '../../../package.json' with { type: 'json' }
 import {
   authCommand,
   channelCommand,
+  chatCommand,
   fileCommand,
   messageCommand,
   reactionCommand,
@@ -49,6 +50,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(teamCommand)
 program.addCommand(channelCommand)
+program.addCommand(chatCommand)
 program.addCommand(fileCommand)
 program.addCommand(messageCommand)
 program.addCommand(reactionCommand)

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

@@ -169,6 +169,102 @@ describe('TeamsClient', () => {
     })
   })
 
+  describe('listChats', () => {
+    it('classifies chats and excludes teams', async () => {
+      mockResponse({
+        conversations: [
+          {
+            id: '19:team@thread.tacv2',
+            threadProperties: { groupId: '111', spaceThreadTopic: 'Team One', threadType: 'space' },
+          },
+          {
+            id: '48:notes',
+            threadProperties: { threadType: 'streamofnotes', productThreadType: 'StreamOfNotes' },
+            lastMessage: { content: 'Hi', composetime: '2024-01-03T00:00:00.000Z' },
+          },
+          {
+            id: '19:1on1@unq.gbl.spaces',
+            lastMessage: { content: '<p>Hi there</p>', composetime: '2024-01-01T00:00:00.000Z' },
+          },
+          {
+            id: '19:group@thread.tacv2',
+            threadProperties: { topic: 'Group Chat', threadType: 'chat' },
+            lastMessage: { content: 'Hello group', composetime: '2024-01-02T00:00:00.000Z' },
+          },
+        ],
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const chats = await client.listChats()
+
+      expect(chats).toHaveLength(3)
+      expect(chats[0]).toMatchObject({ id: '48:notes', type: 'self', last_message: 'Hi' })
+      expect(chats[1]).toMatchObject({ id: '19:1on1@unq.gbl.spaces', type: 'oneOnOne', last_message: 'Hi there' })
+      expect(chats[2]).toMatchObject({ id: '19:group@thread.tacv2', type: 'group', topic: 'Group Chat' })
+      expect(fetchCalls[0].url).toBe(
+        'https://msgapi.teams.live.com/v1/users/ME/conversations?view=msnp24Equivalent&pageSize=500',
+      )
+    })
+  })
+
+  describe('getChatMessages', () => {
+    it('returns user messages and filters system events', async () => {
+      mockResponse({
+        messages: [
+          {
+            id: 'm1',
+            content: '<p>Hello</p>',
+            from: 'host/users/ME/contacts/8:alice',
+            imdisplayname: 'Alice',
+            composetime: '2024-01-01T00:00:00.000Z',
+            messagetype: 'RichText/Html',
+          },
+          {
+            id: 'm2',
+            content: 'Bob joined',
+            imdisplayname: 'System',
+            composetime: '2024-01-01T00:01:00.000Z',
+            messagetype: 'ThreadActivity/AddMember',
+          },
+        ],
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const messages = await client.getChatMessages('19:1on1@unq.gbl.spaces', 30)
+
+      expect(messages).toHaveLength(1)
+      expect(messages[0].id).toBe('m1')
+      expect(messages[0].content).toBe('Hello')
+      expect(messages[0].author.displayName).toBe('Alice')
+      expect(messages[0].channel_id).toBe('19:1on1@unq.gbl.spaces')
+      expect(fetchCalls[0].url).toBe(
+        'https://msgapi.teams.live.com/v1/users/ME/conversations/19%3A1on1%40unq.gbl.spaces/messages?startTime=0&view=msnp24Equivalent&pageSize=30',
+      )
+    })
+  })
+
+  describe('sendChatMessage', () => {
+    it('sends an HTML-escaped message to a chat', async () => {
+      mockResponse({ OriginalArrivalTime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const message = await client.sendChatMessage('19:1on1@unq.gbl.spaces', 'a <b> & c')
+
+      expect(message.content).toBe('a <b> & c')
+      expect(fetchCalls[0].url).toBe(
+        'https://msgapi.teams.live.com/v1/users/ME/conversations/19%3A1on1%40unq.gbl.spaces/messages',
+      )
+      expect(fetchCalls[0].options?.method).toBe('POST')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: 'a &lt;b&gt; &amp; c',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+        }),
+      )
+    })
+  })
+
   describe('getTeam', () => {
     it('returns team info', async () => {
       mockResponse({ id: '111', name: 'Test Team', description: 'A test team' })

package/src/platforms/teams/client.ts

@@ -5,6 +5,8 @@ import { TeamsCredentialManager } from './credential-manager'
 import type {
   TeamsAccountType,
   TeamsChannel,
+  TeamsChat,
+  TeamsChatType,
   TeamsFile,
   TeamsMessage,
   TeamsRegion,
@@ -25,6 +27,41 @@ const BASE_BACKOFF_MS = 100
 const DEFAULT_REGION: TeamsRegion = 'amer'
 const REGIONS: TeamsRegion[] = ['amer', 'emea', 'apac']
 
+function stripHtml(content: string | undefined): string | undefined {
+  if (content === undefined) return undefined
+  const stripped = content.replace(/<[^>]*>/g, '')
+  return stripped
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;')
+}
+
+// groupId => Teams/channel thread (handled by listTeams). "48:notes"/
+// streamofnotes => the user's self ("to me") chat. Anything else without a
+// non-chat threadType is a normal 1:1 (no topic) or group (has topic) chat.
+function classifyChat(
+  id: string,
+  tp?: { topic?: string; threadType?: string; groupId?: string },
+): TeamsChatType | null {
+  if (tp?.groupId) return null
+  if (id === '48:notes' || tp?.threadType === 'streamofnotes') return 'self'
+  if (tp?.threadType && tp.threadType !== 'chat') return null
+  return tp?.topic ? 'group' : 'oneOnOne'
+}
+
 export class TeamsClient {
   private token: string | null = null
   private tokenExpiresAt?: Date
@@ -324,6 +361,102 @@ export class TeamsClient {
     return Array.from(teamsMap.values())
   }
 
+  async listChats(): Promise<TeamsChat[]> {
+    interface ConversationMessage {
+      content?: string
+      composetime?: string
+      originalarrivaltime?: string
+    }
+    interface Conversation {
+      id: string
+      threadProperties?: {
+        topic?: string
+        threadType?: string
+        groupId?: string
+      }
+      lastMessage?: ConversationMessage
+    }
+    interface ConversationsResponse {
+      conversations: Conversation[]
+    }
+    const data = await this.request<ConversationsResponse>(
+      'GET',
+      '/users/ME/conversations?view=msnp24Equivalent&pageSize=500',
+    )
+
+    const chats: TeamsChat[] = []
+    for (const conv of data.conversations ?? []) {
+      const type = classifyChat(conv.id, conv.threadProperties)
+      if (!type) continue
+
+      chats.push({
+        id: conv.id,
+        type,
+        topic: conv.threadProperties?.topic,
+        last_message: stripHtml(conv.lastMessage?.content),
+        last_message_at: conv.lastMessage?.composetime ?? conv.lastMessage?.originalarrivaltime,
+      })
+    }
+
+    return chats
+  }
+
+  async getChatMessages(chatId: string, limit: number = 50): Promise<TeamsMessage[]> {
+    interface ChatMessage {
+      id: string
+      content?: string
+      from?: string
+      imdisplayname?: string
+      composetime?: string
+      originalarrivaltime?: string
+      messagetype?: string
+    }
+    interface MessagesResponse {
+      messages: ChatMessage[]
+    }
+    const encodedChatId = encodeURIComponent(chatId)
+    const data = await this.request<MessagesResponse>(
+      'GET',
+      `/users/ME/conversations/${encodedChatId}/messages?startTime=0&view=msnp24Equivalent&pageSize=${limit}`,
+    )
+
+    const userMessageTypes = new Set(['Text', 'RichText/Html', 'RichText/Media_CallRecording'])
+    return (data.messages ?? [])
+      .filter((msg) => !msg.messagetype || userMessageTypes.has(msg.messagetype))
+      .slice(0, limit)
+      .map((msg) => ({
+        id: msg.id,
+        channel_id: chatId,
+        author: {
+          id: msg.from ?? '',
+          displayName: msg.imdisplayname ?? 'Unknown',
+        },
+        content: stripHtml(msg.content) ?? '',
+        timestamp: msg.composetime ?? msg.originalarrivaltime ?? '',
+      }))
+  }
+
+  async sendChatMessage(chatId: string, content: string): Promise<TeamsMessage> {
+    interface SendResponse {
+      OriginalArrivalTime?: number
+    }
+    const encodedChatId = encodeURIComponent(chatId)
+    const response = await this.request<SendResponse>('POST', `/users/ME/conversations/${encodedChatId}/messages`, {
+      content: escapeHtml(content),
+      messagetype: 'RichText/Html',
+      contenttype: 'text',
+    })
+
+    const arrivalTime = response?.OriginalArrivalTime
+    return {
+      id: arrivalTime ? String(arrivalTime) : '',
+      channel_id: chatId,
+      author: { id: 'ME', displayName: 'Me' },
+      content,
+      timestamp: arrivalTime ? new Date(arrivalTime).toISOString() : new Date().toISOString(),
+    }
+  }
+
   async getTeam(teamId: string): Promise<TeamsTeam> {
     return this.request<TeamsTeam>('GET', `/csa/api/v1/teams/${teamId}`, undefined, CSA_API_BASE)
   }

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

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
+
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+import { historyAction, listAction, sendAction } from './chat'
+
+let clientListChatsSpy: ReturnType<typeof spyOn>
+let clientGetChatMessagesSpy: ReturnType<typeof spyOn>
+let clientSendChatMessageSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+const originalConsoleLog = console.log
+
+beforeEach(() => {
+  clientListChatsSpy = spyOn(TeamsClient.prototype, 'listChats').mockResolvedValue([
+    { id: '19:1on1@unq.gbl.spaces', type: 'oneOnOne', last_message: 'Hi', last_message_at: '2025-01-29T10:00:00Z' },
+    { id: '19:group@thread.tacv2', type: 'group', topic: 'Group Chat' },
+  ])
+
+  clientGetChatMessagesSpy = spyOn(TeamsClient.prototype, 'getChatMessages').mockResolvedValue([
+    {
+      id: 'msg_123',
+      channel_id: '19:1on1@unq.gbl.spaces',
+      author: { id: 'user_789', displayName: 'Alice' },
+      content: 'Hello world',
+      timestamp: '2025-01-29T10:00:00Z',
+    },
+  ])
+
+  clientSendChatMessageSpy = spyOn(TeamsClient.prototype, 'sendChatMessage').mockResolvedValue({
+    id: '1704067200000',
+    channel_id: '19:1on1@unq.gbl.spaces',
+    author: { id: 'ME', displayName: 'Me' },
+    content: 'Hello world',
+    timestamp: '2025-01-29T10:00:00Z',
+  })
+
+  credManagerLoadSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
+    current_account: 'personal',
+    accounts: {
+      personal: {
+        token: 'test_token',
+        account_type: 'personal' as const,
+        current_team: null,
+        teams: {},
+      },
+    },
+  })
+})
+
+afterEach(() => {
+  clientListChatsSpy?.mockRestore()
+  clientGetChatMessagesSpy?.mockRestore()
+  clientSendChatMessageSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+it('list: returns array of chats', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction({ pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('19:1on1@unq.gbl.spaces')
+  expect(output).toContain('19:group@thread.tacv2')
+})
+
+it('history: returns array of messages', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await historyAction('19:1on1@unq.gbl.spaces', { limit: 50, pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('Alice')
+})
+
+it('history: falls back to default limit when given a non-positive value', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await historyAction('19:1on1@unq.gbl.spaces', { limit: -5, pretty: false })
+
+  expect(clientGetChatMessagesSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 50)
+})
+
+it('send: returns sent message', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('19:1on1@unq.gbl.spaces', 'Hello world', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('Hello world')
+})

package/src/platforms/teams/commands/chat.ts

@@ -0,0 +1,131 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+export async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
+    const chats = await client.listChats()
+
+    const output = chats.map((chat) => ({
+      id: chat.id,
+      type: chat.type,
+      topic: chat.topic,
+      last_message: chat.last_message,
+      last_message_at: chat.last_message_at,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function historyAction(chatId: string, options: { limit?: number; pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
+    const limit = options.limit && options.limit > 0 ? options.limit : 50
+    const messages = await client.getChatMessages(chatId, limit)
+
+    const output = messages.map((msg) => ({
+      id: msg.id,
+      author: msg.author.displayName,
+      content: msg.content,
+      timestamp: msg.timestamp,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function sendAction(chatId: string, content: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
+    const message = await client.sendChatMessage(chatId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const chatCommand = new Command('chat')
+  .description('Chat commands (1:1, group, and self chats)')
+  .addCommand(
+    new Command('list')
+      .description('List 1:1, group, and self chats')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('history')
+      .description('Get chat message history')
+      .argument('<chat-id>', 'Chat ID')
+      .option('--limit <n>', 'Number of messages to fetch', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((chatId, options) => {
+        return historyAction(chatId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      }),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a message to a chat')
+      .argument('<chat-id>', 'Chat ID')
+      .argument('<content>', 'Message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )

package/src/platforms/teams/commands/index.ts

@@ -4,6 +4,7 @@
 
 export { authCommand } from './auth'
 export { channelCommand } from './channel'
+export { chatCommand } from './chat'
 export { fileCommand } from './file'
 export { messageCommand } from './message'
 export { reactionCommand } from './reaction'

package/src/platforms/teams/types.ts

@@ -35,6 +35,16 @@ export interface TeamsUser {
   userPrincipalName?: string
 }
 
+export type TeamsChatType = 'oneOnOne' | 'group' | 'self'
+
+export interface TeamsChat {
+  id: string
+  type: TeamsChatType
+  topic?: string
+  last_message?: string
+  last_message_at?: string
+}
+
 export interface TeamsReaction {
   emoji: string
   count: number
@@ -124,6 +134,16 @@ export const TeamsUserSchema = z.object({
   userPrincipalName: z.string().optional(),
 })
 
+export const TeamsChatTypeSchema = z.enum(['oneOnOne', 'group', 'self'])
+
+export const TeamsChatSchema = z.object({
+  id: z.string(),
+  type: TeamsChatTypeSchema,
+  topic: z.string().optional(),
+  last_message: z.string().optional(),
+  last_message_at: z.string().optional(),
+})
+
 export const TeamsReactionSchema = z.object({
   emoji: z.string(),
   count: z.number(),

package/src/tui/adapters/line-adapter.ts

@@ -37,7 +37,7 @@ export class LineAdapter implements PlatformAdapter {
     return messages.map((msg) => ({
       id: msg.message_id,
       channelId,
-      author: msg.author_id ?? 'unknown',
+      author: msg.author_name ?? msg.author_id ?? 'unknown',
       content: msg.text ?? '',
       timestamp: msg.sent_at,
     }))