agent-messenger 2.29.0 → 2.30.0

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

@@ -0,0 +1,243 @@
+import { afterEach, describe, expect, mock, it } from 'bun:test'
+
+import { TeamsListener } from '@/platforms/teams/listener'
+import type { TeamsRealtimeMessage } from '@/platforms/teams/types'
+
+type WsHandler = (...args: any[]) => void
+
+let mockWsInstance: MockWs
+
+class MockWs {
+  static OPEN = 1
+  static CLOSED = 3
+  readyState = MockWs.OPEN
+
+  private handlers = new Map<string, WsHandler[]>()
+  sent: string[] = []
+
+  constructor(_url: string, _options?: any) {
+    // oxlint-disable-next-line typescript-eslint/no-this-alias
+    mockWsInstance = this
+  }
+
+  on(event: string, handler: WsHandler) {
+    const list = this.handlers.get(event) ?? []
+    list.push(handler)
+    this.handlers.set(event, list)
+  }
+
+  send(data: string) {
+    this.sent.push(data)
+  }
+
+  close() {
+    this.readyState = MockWs.CLOSED
+  }
+
+  emit(event: string, ...args: any[]) {
+    for (const handler of this.handlers.get(event) ?? []) {
+      handler(...args)
+    }
+  }
+
+  simulateFrame(frame: string) {
+    this.emit('message', Buffer.from(frame))
+  }
+}
+
+mock.module('ws', () => ({ default: MockWs, __esModule: true }))
+
+const actualTrouter = await import('@/platforms/teams/trouter')
+mock.module('@/platforms/teams/trouter', () => ({
+  ...actualTrouter,
+  fetchTrouterInfo: mock(() => Promise.resolve({ socketio: 'wss://fake/', surl: 'https://fake/', connectparams: {} })),
+  fetchTrouterSessionId: mock(() => Promise.resolve('SESSION')),
+  registerEndpoint: mock(() => Promise.resolve()),
+}))
+
+function messageFrame(resource: Record<string, unknown>): string {
+  const body = JSON.stringify({ resourceType: 'NewMessage', resource })
+  return `3:::${JSON.stringify({ id: 1, url: '/v4/f/HASH/messaging', body })}`
+}
+
+function conversationLink(conversationId: string): string {
+  return `https://notifications.skype.net/v1/users/ME/conversations/${conversationId}`
+}
+
+function createMockClient(channelTeamMap: Map<string, string> = new Map()) {
+  return {
+    getToken: mock(() => 'skype-token'),
+    getIdToken: mock(() => Promise.resolve('id-token')),
+    getAccountType: mock(() => 'work'),
+    buildChannelTeamMap: mock(() => Promise.resolve(channelTeamMap)),
+  } as any
+}
+
+async function startAndCapture(
+  client: ReturnType<typeof createMockClient>,
+): Promise<{ listener: TeamsListener; messages: TeamsRealtimeMessage[] }> {
+  const listener = new TeamsListener(client)
+  const messages: TeamsRealtimeMessage[] = []
+  listener.on('message', (message) => messages.push(message))
+  await listener.start()
+  return { listener, messages }
+}
+
+async function flushMicrotasks(): Promise<void> {
+  for (let i = 0; i < 5; i++) await Promise.resolve()
+}
+
+describe('TeamsListener.emitMessage', () => {
+  let listener: TeamsListener
+
+  afterEach(() => {
+    listener?.stop()
+  })
+
+  it('classifies a 1:1 chat and carries no team/channel context', async () => {
+    const client = createMockClient()
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    mockWsInstance.simulateFrame(
+      messageFrame({
+        id: 'm1',
+        messagetype: 'RichText/Html',
+        content: 'hello there',
+        from: 'https://x/contacts/8:orgid:alice',
+        imdisplayname: 'Alice',
+        conversationLink: conversationLink('19:uni01_abc@unq.gbl.spaces'),
+      }),
+    )
+    await flushMicrotasks()
+
+    expect(started.messages).toHaveLength(1)
+    const message = started.messages[0]
+    expect(message.chatId).toBe('19:uni01_abc@unq.gbl.spaces')
+    expect(message.conversationType).toBe('chat')
+    expect(message.teamId).toBeUndefined()
+    expect(message.channelId).toBeUndefined()
+    expect(message.content).toBe('hello there')
+    expect(message.mentions).toEqual([])
+    expect(message.author).toEqual({ id: '8:orgid:alice', displayName: 'Alice' })
+  })
+
+  it('classifies a group chat thread with no groupId as a chat', async () => {
+    const client = createMockClient()
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    mockWsInstance.simulateFrame(
+      messageFrame({
+        id: 'm2',
+        messagetype: 'RichText/Html',
+        content: 'group hi',
+        from: 'https://x/contacts/8:orgid:bob',
+        imdisplayname: 'Bob',
+        conversationLink: conversationLink('19:group_xyz@thread.tacv2'),
+      }),
+    )
+    await flushMicrotasks()
+
+    expect(started.messages).toHaveLength(1)
+    const message = started.messages[0]
+    expect(message.chatId).toBe('19:group_xyz@thread.tacv2')
+    expect(message.conversationType).toBe('chat')
+    expect(message.teamId).toBeUndefined()
+    expect(message.channelId).toBeUndefined()
+  })
+
+  it('does not refresh the channel map for every group-chat message', async () => {
+    const client = createMockClient()
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    for (const id of ['g1', 'g2', 'g3']) {
+      mockWsInstance.simulateFrame(
+        messageFrame({
+          id,
+          messagetype: 'RichText/Html',
+          content: 'group hi',
+          from: 'https://x/contacts/8:orgid:bob',
+          imdisplayname: 'Bob',
+          conversationLink: conversationLink('19:group_xyz@thread.tacv2'),
+        }),
+      )
+      await flushMicrotasks()
+    }
+
+    expect(started.messages).toHaveLength(3)
+    // One build at start() + one refresh on the first miss; the negative cache
+    // prevents a fetch on the 2nd and 3rd messages.
+    expect(client.buildChannelTeamMap).toHaveBeenCalledTimes(2)
+  })
+
+  it('classifies a team channel message and resolves teamId plus mentions', async () => {
+    const channelId = '19:channel_abc@thread.tacv2'
+    const client = createMockClient(new Map([[channelId, 'team-group-id']]))
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    mockWsInstance.simulateFrame(
+      messageFrame({
+        id: 'm3',
+        messagetype: 'RichText/Html',
+        content: '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="0">Alice</span> please review',
+        from: 'https://x/contacts/8:orgid:bob',
+        imdisplayname: 'Bob',
+        conversationLink: conversationLink(channelId),
+        properties: {
+          mentions: [{ itemid: '0', mri: '8:orgid:alice', mentionType: 'person', displayName: 'Alice' }],
+        },
+      }),
+    )
+    await flushMicrotasks()
+
+    expect(started.messages).toHaveLength(1)
+    const message = started.messages[0]
+    expect(message.conversationType).toBe('channel')
+    expect(message.teamId).toBe('team-group-id')
+    expect(message.channelId).toBe(channelId)
+    expect(message.content).toBe('Alice please review')
+    expect(message.mentions).toEqual([{ id: '0', mri: '8:orgid:alice', displayName: 'Alice' }])
+  })
+
+  it('does not re-emit a message with a duplicate id', async () => {
+    const client = createMockClient()
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    const frame = messageFrame({
+      id: 'dup',
+      messagetype: 'Text',
+      content: 'once',
+      from: 'https://x/contacts/8:orgid:alice',
+      imdisplayname: 'Alice',
+      conversationLink: conversationLink('19:uni01_abc@unq.gbl.spaces'),
+    })
+    mockWsInstance.simulateFrame(frame)
+    await flushMicrotasks()
+    mockWsInstance.simulateFrame(frame)
+    await flushMicrotasks()
+
+    expect(started.messages).toHaveLength(1)
+  })
+
+  it('ignores non-text message types', async () => {
+    const client = createMockClient()
+    const started = await startAndCapture(client)
+    listener = started.listener
+
+    mockWsInstance.simulateFrame(
+      messageFrame({
+        id: 'sys',
+        messagetype: 'ThreadActivity/AddMember',
+        content: '',
+        conversationLink: conversationLink('19:uni01_abc@unq.gbl.spaces'),
+      }),
+    )
+    await flushMicrotasks()
+
+    expect(started.messages).toHaveLength(0)
+  })
+})

package/src/platforms/teams/listener.ts

@@ -16,6 +16,8 @@ import {
   fetchTrouterInfo,
   fetchTrouterSessionId,
   isMessageLossFrame,
+  isThreadConversation,
+  parseMentions,
   parseRequestFrame,
   registerEndpoint,
   type TrouterInfo,
@@ -40,6 +42,7 @@ interface IncomingResource {
   imdisplayname?: string
   conversationLink?: string
   resourceLink?: string
+  properties?: unknown
 }
 
 export class TeamsListener {
@@ -56,6 +59,9 @@ export class TeamsListener {
   private reregisterTimer: ReturnType<typeof setInterval> | null = null
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
   private seenMessageIds = new Set<string>()
+  private channelTeamMap = new Map<string, string>()
+  private channelMapRefreshing: Promise<void> | null = null
+  private nonChannelThreads = new Set<string>()
 
   constructor(client: TeamsClient) {
     this.client = client
@@ -65,6 +71,7 @@ export class TeamsListener {
     if (this.running) return
     this.running = true
     this.reconnectAttempts = 0
+    await this.refreshChannelMap()
     await this.connect()
   }
 
@@ -214,7 +221,9 @@ export class TeamsListener {
         resource?: IncomingResource
       }
       if (decoded.resourceType === 'NewMessage' && decoded.resource) {
-        this.emitMessage(decoded.resource)
+        void this.emitMessage(decoded.resource).catch((error) => {
+          this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+        })
       }
       this.emitter.emit('teams_event', { resourceType: decoded.resourceType ?? 'unknown', ...decoded })
     } catch (error) {
@@ -222,18 +231,29 @@ export class TeamsListener {
     }
   }
 
-  private emitMessage(resource: IncomingResource): void {
+  private async emitMessage(resource: IncomingResource): Promise<void> {
     if (!resource.messagetype || !TEXT_MESSAGE_TYPES.has(resource.messagetype)) return
 
     const chatId = extractChatId(resource.conversationLink ?? resource.resourceLink)
     if (!chatId || !resource.id) return
+
+    // Dedup before the async classification so duplicate frames don't trigger
+    // redundant channel-map refreshes.
     if (this.seenMessageIds.has(resource.id)) return
     this.rememberMessageId(resource.id)
 
+    const classification = await this.classifyConversation(chatId)
+    if (!this.running) return
+
+    const rawContent = resource.content ?? ''
     const message: TeamsRealtimeMessage = {
       id: resource.id,
       chatId,
-      content: stripHtml(resource.content ?? ''),
+      conversationType: classification.conversationType,
+      teamId: classification.teamId,
+      channelId: classification.channelId,
+      content: stripHtml(rawContent),
+      mentions: parseMentions(resource.properties, rawContent),
       author: {
         id: extractUserId(resource.from) ?? 'unknown',
         displayName: resource.imdisplayname || extractUserId(resource.from) || 'unknown',
@@ -244,6 +264,42 @@ export class TeamsListener {
     this.emitter.emit('message', message)
   }
 
+  private async classifyConversation(
+    chatId: string,
+  ): Promise<Pick<TeamsRealtimeMessage, 'conversationType' | 'teamId' | 'channelId'>> {
+    if (!isThreadConversation(chatId)) return { conversationType: 'chat' }
+
+    let teamId = this.channelTeamMap.get(chatId)
+    // A thread we haven't cached may be a channel created/joined since start;
+    // one best-effort refresh resolves it. Group chats also look like threads
+    // but never carry a groupId, so remember the miss to avoid re-fetching
+    // /users/ME/conversations on every one of their messages.
+    if (!teamId && !this.nonChannelThreads.has(chatId)) {
+      await this.refreshChannelMap()
+      teamId = this.channelTeamMap.get(chatId)
+      if (!teamId) this.nonChannelThreads.add(chatId)
+    }
+    if (!teamId) return { conversationType: 'chat' }
+
+    return { conversationType: 'channel', teamId, channelId: chatId }
+  }
+
+  private async refreshChannelMap(): Promise<void> {
+    if (this.channelMapRefreshing) return this.channelMapRefreshing
+    this.channelMapRefreshing = this.client
+      .buildChannelTeamMap()
+      .then((map) => {
+        this.channelTeamMap = map
+      })
+      .catch((error) => {
+        this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      })
+      .finally(() => {
+        this.channelMapRefreshing = null
+      })
+    return this.channelMapRefreshing
+  }
+
   private rememberMessageId(id: string): void {
     this.seenMessageIds.add(id)
     if (this.seenMessageIds.size > MESSAGE_CACHE_LIMIT) {

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

@@ -11,6 +11,8 @@ import {
   decodeMessageBody,
   extractChatId,
   isMessageLossFrame,
+  isThreadConversation,
+  parseMentions,
   parseRequestFrame,
   type TrouterInfo,
 } from './trouter'
@@ -112,3 +114,61 @@ it('decodeMessageBody unwraps nested gp (base64) payloads', () => {
   const decoded = decodeMessageBody({}, JSON.stringify({ gp }))
   expect(decoded).toEqual({ resourceType: 'NewMessage' })
 })
+
+it('isThreadConversation flags @thread ids and rejects 1:1 conversations', () => {
+  expect(isThreadConversation('19:abc@thread.tacv2')).toBe(true)
+  expect(isThreadConversation('19:abc@thread.v2')).toBe(true)
+  expect(isThreadConversation('19:uni01_abc@unq.gbl.spaces')).toBe(false)
+  expect(isThreadConversation('8:orgid:user@oneToOne.skype')).toBe(false)
+})
+
+it('parseMentions prefers the authoritative properties.mentions array', () => {
+  const properties = {
+    mentions: [
+      { itemid: '0', mri: '8:orgid:aaa', mentionType: 'person', displayName: 'Alice' },
+      { itemid: '1', mri: '8:orgid:bbb', mentionType: 'person', displayName: 'Bob' },
+    ],
+  }
+  const content =
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="0">Alice</span> ' +
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="1">Bob</span> hi'
+  expect(parseMentions(properties, content)).toEqual([
+    { id: '0', mri: '8:orgid:aaa', displayName: 'Alice' },
+    { id: '1', mri: '8:orgid:bbb', displayName: 'Bob' },
+  ])
+})
+
+it('parseMentions accepts JSON-stringified properties and mentions', () => {
+  const properties = JSON.stringify({
+    mentions: JSON.stringify([{ itemid: '0', mri: '8:orgid:aaa', displayName: 'Alice' }]),
+  })
+  expect(parseMentions(properties, '')).toEqual([{ id: '0', mri: '8:orgid:aaa', displayName: 'Alice' }])
+})
+
+it('parseMentions keeps tag mentions', () => {
+  const properties = { mentions: [{ itemid: '0', mri: 'tag:eng', mentionType: 'tag', displayName: 'Engineering' }] }
+  expect(parseMentions(properties, '')).toEqual([{ id: '0', mri: 'tag:eng', displayName: 'Engineering' }])
+})
+
+it('parseMentions falls back to content spans when properties are absent', () => {
+  const content =
+    '<readonly class="skipProofing" itemtype="http://schema.skype.com/Mention" contenteditable="false">' +
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="0">Alice</span></readonly> hi'
+  expect(parseMentions(undefined, content)).toEqual([{ id: '0', displayName: 'Alice' }])
+})
+
+it('parseMentions skips property entries missing itemid', () => {
+  const properties = {
+    mentions: [
+      { mri: '8:orgid:aaa', displayName: 'Alice' },
+      { itemid: '1', displayName: 'Bob' },
+    ],
+  }
+  expect(parseMentions(properties, '')).toEqual([{ id: '1', mri: undefined, displayName: 'Bob' }])
+})
+
+it('parseMentions returns an empty array for malformed data', () => {
+  expect(parseMentions('not-json', '')).toEqual([])
+  expect(parseMentions({ mentions: 'not-json' }, '')).toEqual([])
+  expect(parseMentions(null, 'plain text with no mentions')).toEqual([])
+})

package/src/platforms/teams/trouter.ts

@@ -226,3 +226,98 @@ export function extractChatId(link: string | undefined): string | null {
   const match = link.match(/conversations\/([^/]+)/)
   return match ? decodeURIComponent(match[1]) : null
 }
+
+// `id` is Teams' positional mention index (the content span's `itemid`); `mri`
+// is the target's Skype MRI, present only via `properties.mentions` metadata.
+export interface TrouterMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
+// 1:1 chats resolve to a unique roster / one-to-one conversation id; anything on
+// a thread (group chat OR team channel) shares the @thread.* family. The thread
+// family alone cannot tell a group chat from a channel — that needs the
+// conversation's groupId, which the realtime resource does not carry.
+export function isThreadConversation(conversationId: string): boolean {
+  return conversationId.includes('@thread.tacv2') || conversationId.includes('@thread.v2')
+}
+
+function parseJsonRecord(value: unknown): Record<string, unknown> | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  if (typeof source !== 'object' || source === null || Array.isArray(source)) return undefined
+  return source as Record<string, unknown>
+}
+
+function parseJsonArray(value: unknown): unknown[] | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  return Array.isArray(source) ? source : undefined
+}
+
+function safeJsonParse(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}
+
+// Mentions arrive two ways: the authoritative `properties.mentions` array (JSON
+// or JSON-string) carries real MRIs, while the message content only has
+// positional `<span itemtype=".../Mention" itemid="N">Name</span>` markup with
+// no MRI. Prefer the metadata; fall back to scraping the content spans so a
+// mention is still surfaced when properties are missing. Never throws — bad
+// data yields an empty list.
+export function parseMentions(properties: unknown, content: string): TrouterMention[] {
+  const fromProperties = parseMentionsFromProperties(properties)
+  if (fromProperties.length > 0) return fromProperties
+  return parseMentionsFromContent(content)
+}
+
+function parseMentionsFromProperties(properties: unknown): TrouterMention[] {
+  const record = parseJsonRecord(properties)
+  if (!record) return []
+  const rawMentions = parseJsonArray(record.mentions)
+  if (!rawMentions) return []
+
+  const mentions: TrouterMention[] = []
+  for (const entry of rawMentions) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const item = entry as Record<string, unknown>
+    const id = item.itemid
+    if (typeof id !== 'string' && typeof id !== 'number') continue
+    mentions.push({
+      id: String(id),
+      mri: typeof item.mri === 'string' ? item.mri : undefined,
+      displayName: typeof item.displayName === 'string' ? item.displayName : '',
+    })
+  }
+  return mentions
+}
+
+const MENTION_SPAN_REGEX = /<span\b[^>]*itemtype=["'][^"']*Mention[^"']*["'][^>]*>(.*?)<\/span>/gi
+
+function parseMentionsFromContent(content: string): TrouterMention[] {
+  const mentions: TrouterMention[] = []
+  for (const match of content.matchAll(MENTION_SPAN_REGEX)) {
+    const attributes = match[0]
+    const itemId = attributes.match(/itemid=["']([^"']*)["']/i)?.[1]
+    if (itemId === undefined) continue
+    mentions.push({
+      id: itemId,
+      displayName: stripTags(match[1]),
+    })
+  }
+  return mentions
+}
+
+function stripTags(html: string): string {
+  return html
+    .replace(/<[^>]*>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .trim()
+}

package/src/platforms/teams/types.ts

@@ -252,10 +252,20 @@ export const TeamsConfigLegacySchema = z.object({
   ),
 })
 
+export interface TeamsMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
 export interface TeamsRealtimeMessage {
   id: string
   chatId: string
+  conversationType: 'chat' | 'channel'
+  teamId?: string
+  channelId?: string
   content: string
+  mentions: TeamsMention[]
   author: {
     id: string
     displayName: string

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

@@ -235,3 +235,63 @@ describe('sendMessage confirmation', () => {
     expect(result.id).toBe(serverId)
   })
 })
+
+describe('editMessage', () => {
+  it('returns the edited message from the editMessageText response', async () => {
+    const events: any[] = []
+    let editRequest: any = null
+
+    const createClientId = mock(() => 1)
+    const send = mock((_clientId: number, request: any) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        events.push({
+          '@type': 'updateAuthorizationState',
+          authorization_state: { '@type': 'authorizationStateReady' },
+          '@extra': request['@extra'],
+        })
+      }
+
+      if (request['@type'] === 'getChat') {
+        events.push({ '@type': 'chat', id: 42, title: 'test', unread_count: 0, '@extra': request['@extra'] })
+      }
+
+      if (request['@type'] === 'editMessageText') {
+        editRequest = request
+        events.push({
+          '@type': 'message',
+          id: 555,
+          chat_id: 42,
+          date: 1_710_000_002,
+          is_outgoing: true,
+          sender_id: { '@type': 'messageSenderUser', user_id: 1 },
+          content: {
+            '@type': 'messageText',
+            text: { '@type': 'formattedText', text: 'edited text', entities: [] },
+          },
+          '@extra': request['@extra'],
+        })
+      }
+    })
+
+    const receive = mock(() => events.shift() ?? null)
+    const client = new (TelegramTdlibClient as unknown as new (
+      account: TelegramAccount,
+      paths: TelegramAccountPaths,
+      tdjson: any,
+    ) => TelegramTdlibClient)(mockAccount, mockPaths, {
+      createClientId,
+      send,
+      receive,
+      libraryPath: '/mock/lib',
+    })
+
+    const result = await client.editMessage('42', 555, 'edited text')
+
+    expect(result.id).toBe(555)
+    expect(result.text).toBe('edited text')
+    expect(editRequest.chat_id).toBe(42)
+    expect(editRequest.message_id).toBe(555)
+    expect(editRequest.input_message_content['@type']).toBe('inputMessageText')
+    expect(editRequest.input_message_content.text.text).toBe('edited text')
+  })
+})

package/src/platforms/telegram/client.ts

@@ -312,6 +312,30 @@ export class TelegramTdlibClient {
     return simplifyMessage(message, chat.id)
   }
 
+  async editMessage(reference: string, messageId: number, text: string): Promise<TelegramMessageSummary> {
+    await this.ensureReady()
+    const chat = await this.resolveChat(reference)
+
+    const message = (await this.call({
+      '@type': 'editMessageText',
+      chat_id: chat.id,
+      message_id: messageId,
+      reply_markup: null,
+      input_message_content: {
+        '@type': 'inputMessageText',
+        text: {
+          '@type': 'formattedText',
+          text,
+          entities: [],
+        },
+        link_preview_options: null,
+        clear_draft: false,
+      },
+    })) as TdMessage
+
+    return simplifyMessage(message, chat.id)
+  }
+
   private async ensureReady(): Promise<void> {
     const state = await this.connect()
     if (state?.['@type'] !== 'authorizationStateReady') {