agent-messenger 2.19.4 → 2.20.0

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

@@ -87,6 +87,23 @@ describe('LineMessageSchema', () => {
     expect(result.text).toBeNull()
   })
 
+  it('parses message with decryption error', () => {
+    const data = {
+      message_id: 'msg789',
+      chat_id: 'u1234567890abcdef',
+      author_id: 'u9876543210fedcba',
+      text: null,
+      decryption_error: {
+        code: 'missing_e2ee_key',
+        message: 'LINE message is encrypted with Letter Sealing, but this session has no saved E2EE key material.',
+      },
+      content_type: 'NONE',
+      sent_at: '2026-03-29T00:00:00.000Z',
+    }
+    const result = LineMessageSchema.parse(data)
+    expect(result.decryption_error?.code).toBe('missing_e2ee_key')
+  })
+
   it('rejects missing required fields', () => {
     expect(() => LineMessageSchema.parse({ message_id: 'msg123' })).toThrow()
   })

package/src/platforms/line/types.ts

@@ -43,10 +43,16 @@ export interface LineMessage {
   author_id: string
   author_name?: string
   text: string | null
+  decryption_error?: LineDecryptionError
   content_type: string
   sent_at: string
 }
 
+export interface LineDecryptionError {
+  code: 'missing_e2ee_key' | 'decrypt_failed'
+  message: string
+}
+
 export interface LineSendResult {
   success: boolean
   chat_id: string
@@ -106,6 +112,12 @@ export const LineMessageSchema = z.object({
   author_id: z.string(),
   author_name: z.string().optional(),
   text: z.string().nullable(),
+  decryption_error: z
+    .object({
+      code: z.enum(['missing_e2ee_key', 'decrypt_failed']),
+      message: z.string(),
+    })
+    .optional(),
   content_type: z.string(),
   sent_at: z.string(),
 })
@@ -137,6 +149,7 @@ export interface LinePushMessageEvent {
   message_id: string
   author_id: string
   text: string | null
+  decryption_error?: LineDecryptionError
   content_type: string
   // Raw LINE contentMetadata (sticker IDs, file name/size, media URLs); empty for plain text.
   content_metadata: Record<string, string>

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

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, it } from 'bun:test'
+import { afterAll, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 import { mkdirSync, rmSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
@@ -14,6 +14,16 @@ import { type ExtractedWorkspace, TokenExtractor } from '@/platforms/slack/token
 const testConfigDir = join(import.meta.dir, '.test-auth-config')
 const testSlackDir = join(import.meta.dir, '.test-slack-data')
 
+async function extractWithoutBrowserFallback(extractor: TokenExtractor): Promise<ExtractedWorkspace[]> {
+  const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype, 'extractFromBrowsers').mockResolvedValue([])
+
+  try {
+    return await extractor.extract()
+  } finally {
+    extractFromBrowsersSpy.mockRestore()
+  }
+}
+
 describe('TokenExtractor', () => {
   let extractor: TokenExtractor
 
@@ -85,7 +95,7 @@ describe('TokenExtractor', () => {
       extractor = new TokenExtractor('darwin', nonExistentPath)
 
       // when
-      const result = await extractor.extract()
+      const result = await extractWithoutBrowserFallback(extractor)
 
       // then
       expect(result).toEqual([])
@@ -97,7 +107,7 @@ describe('TokenExtractor', () => {
       extractor = new TokenExtractor('darwin', testSlackDir)
 
       // When: extract is called
-      const result = await extractor.extract()
+      const result = await extractWithoutBrowserFallback(extractor)
 
       // Then: Should return empty array
       expect(result).toEqual([])
@@ -463,7 +473,7 @@ describe('Error Handling', () => {
     const extractor = new TokenExtractor('darwin', nonExistentPath)
 
     // when/then — falls back to browser profiles, returns empty array
-    const result = await extractor.extract()
+    const result = await extractWithoutBrowserFallback(extractor)
     expect(result).toEqual([])
   })
 
@@ -472,7 +482,7 @@ describe('Error Handling', () => {
     const extractor = new TokenExtractor('darwin', testSlackDir)
 
     // When: Trying to extract from empty directory
-    const result = await extractor.extract()
+    const result = await extractWithoutBrowserFallback(extractor)
 
     // Then: Should return empty array
     expect(result).toEqual([])
@@ -484,7 +494,7 @@ describe('Error Handling', () => {
     const extractor = new TokenExtractor('darwin', testSlackDir)
 
     // When: Trying to extract
-    const result = await extractor.extract()
+    const result = await extractWithoutBrowserFallback(extractor)
 
     // Then: Should return empty array (no tokens found)
     expect(result).toEqual([])

package/src/platforms/slack/token-extractor.test.ts

@@ -12,6 +12,7 @@ import { ExtractedWorkspace, TokenExtractor } from './token-extractor'
 
 const tempDirs: string[] = []
 const originalAgentBrowserProfile = process.env.AGENT_BROWSER_PROFILE
+const originalLocalAppData = process.env.LOCALAPPDATA
 
 afterEach(() => {
   if (originalAgentBrowserProfile) {
@@ -20,12 +21,34 @@ afterEach(() => {
     delete process.env.AGENT_BROWSER_PROFILE
   }
 
+  if (originalLocalAppData) {
+    process.env.LOCALAPPDATA = originalLocalAppData
+  } else {
+    delete process.env.LOCALAPPDATA
+  }
+
   for (const dir of tempDirs) {
     rmSync(dir, { recursive: true, force: true })
   }
   tempDirs.length = 0
 })
 
+async function extractDesktopOnly(extractor: TokenExtractor): Promise<ExtractedWorkspace[]> {
+  const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype, 'extractFromBrowsers').mockResolvedValue([])
+
+  try {
+    return await extractor.extract()
+  } finally {
+    extractFromBrowsersSpy.mockRestore()
+  }
+}
+
+function useEmptyWindowsBrowserRoot(): void {
+  const browserRoot = mkdtempSync(join(tmpdir(), 'empty-browser-root-'))
+  tempDirs.push(browserRoot)
+  process.env.LOCALAPPDATA = browserRoot
+}
+
 function createCookiesDb(
   dbPath: string,
   cookies: { name: string; value: string; encrypted_value: Uint8Array; host_key: string; last_access_utc: number }[],
@@ -60,7 +83,7 @@ describe('TokenExtractor token deduplication', () => {
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir)
-    const result = await extractor.extract()
+    const result = await extractDesktopOnly(extractor)
 
     // then — first token wins, but team name is upgraded
     expect(result.length).toBe(1)
@@ -383,7 +406,7 @@ describe('TokenExtractor debug logging', () => {
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir, undefined, debugLog)
-    await extractor.extract()
+    await extractDesktopOnly(extractor)
 
     // then — should have emitted debug messages
     expect(messages.length).toBeGreaterThan(0)
@@ -397,7 +420,7 @@ describe('TokenExtractor debug logging', () => {
 
     // when — then — should not throw
     const extractor = new TokenExtractor('darwin', slackDir)
-    const result = await extractor.extract()
+    const result = await extractDesktopOnly(extractor)
     expect(result).toEqual([])
   })
 })
@@ -576,7 +599,7 @@ describe('TokenExtractor Windows DPAPI', () => {
 
     // when
     const extractor = new TestTokenExtractor('win32', slackDir)
-    const result = await extractor.extract()
+    const result = await extractDesktopOnly(extractor)
 
     // then
     expect(result).toEqual([
@@ -711,7 +734,7 @@ describe('TokenExtractor IndexedDB blob files', () => {
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir)
-    const result = await extractor.extract()
+    const result = await extractDesktopOnly(extractor)
 
     // then
     expect(result.length).toBe(0)
@@ -802,17 +825,21 @@ describe('TokenExtractor getWorkspaceDomains', () => {
 
 describe('TokenExtractor browser fallback', () => {
   it('extractFromBrowsers returns empty array when no browser profiles have tokens', async () => {
+    useEmptyWindowsBrowserRoot()
+
     const slackDir = mkdtempSync(join(tmpdir(), 'slack-nonexistent-'))
     tempDirs.push(slackDir)
     rmSync(slackDir, { recursive: true, force: true })
 
-    const extractor = new TokenExtractor('darwin', slackDir)
+    const extractor = new TokenExtractor('win32', slackDir)
     const result = await extractor.extractFromBrowsers()
     expect(result).toEqual([])
   })
 
   it('resolves Local State from agent-browser profile root for encrypted cookies', async () => {
     // given
+    useEmptyWindowsBrowserRoot()
+
     const agentBrowserProfile = mkdtempSync(join(tmpdir(), 'agent-browser-slack-profile-'))
     tempDirs.push(agentBrowserProfile)
     process.env.AGENT_BROWSER_PROFILE = agentBrowserProfile
@@ -839,7 +866,7 @@ describe('TokenExtractor browser fallback', () => {
 
     try {
       // when
-      const extractor = new TokenExtractor('darwin', join(agentBrowserProfile, 'missing-desktop'))
+      const extractor = new TokenExtractor('win32', join(agentBrowserProfile, 'missing-desktop'))
       const result = await extractor.extractFromBrowsers()
 
       // then

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')
+})