agent-messenger 2.19.5 → 2.20.1

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,
     }))