agent-messenger 2.2.0 → 2.4.0

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

@@ -1,89 +1,73 @@
-import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
 import { addAction, removeAction } from './reaction'
 
-let clientAddReactionSpy: ReturnType<typeof spyOn>
-let clientRemoveReactionSpy: ReturnType<typeof spyOn>
-let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+let addReactionSpy: ReturnType<typeof spyOn>
+let removeReactionSpy: ReturnType<typeof spyOn>
+let getTokenWithExpirySpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  clientAddReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
-  clientRemoveReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
-  credManagerLoadConfigSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
-    current_account: 'work',
-    accounts: {
-      work: {
-        token: 'test-token',
-        account_type: 'work' as const,
-        current_team: null,
-        teams: {},
-      },
-    },
+  addReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
+  removeReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
+  getTokenWithExpirySpy = spyOn(TeamsCredentialManager.prototype, 'getTokenWithExpiry').mockImplementation(() =>
+    Promise.resolve({ token: 'test-token', tokenExpiresAt: undefined }),
+  )
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+    throw new Error(`process.exit(${_code})`)
   })
 })
 
 afterEach(() => {
-  clientAddReactionSpy?.mockRestore()
-  clientRemoveReactionSpy?.mockRestore()
-  credManagerLoadConfigSpy?.mockRestore()
+  addReactionSpy.mockRestore()
+  removeReactionSpy.mockRestore()
+  getTokenWithExpirySpy.mockRestore()
+  consoleLogSpy.mockRestore()
+  processExitSpy.mockRestore()
 })
 
 test('add: sends correct POST request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('remove: sends correct DELETE request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await removeAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('add: handles missing token gracefully', async () => {
-  credManagerLoadConfigSpy?.mockResolvedValue(null)
-
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  const originalExit = process.exit
-  process.exit = mock(() => {}) as any
-  console.log = consoleSpy
+  getTokenWithExpirySpy.mockImplementation(() => Promise.resolve(null))
 
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.error).toBeDefined()
-  } finally {
-    console.log = originalLog
-    process.exit = originalExit
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.error).toBeDefined()
+  expect(processExitSpy).toHaveBeenCalledWith(1)
 })

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

@@ -20,6 +20,7 @@ export async function addAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
@@ -56,6 +57,7 @@ export async function removeAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })

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

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListChats = mock(() =>
+  Promise.resolve([
+    { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+    { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+  ]),
+)
+
+const mockSearchChats = mock(() =>
+  Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+)
+
+const mockGetChat = mock(() =>
+  Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+)
+
+const mockClient = {
+  listChats: mockListChats,
+  searchChats: mockSearchChats,
+  getChat: mockGetChat,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { chatCommand } from './chat'
+
+describe('chat commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListChats.mockReset()
+    mockListChats.mockImplementation(() =>
+      Promise.resolve([
+        { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+        { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+      ]),
+    )
+    mockSearchChats.mockReset()
+    mockSearchChats.mockImplementation(() =>
+      Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+    )
+    mockGetChat.mockReset()
+    mockGetChat.mockImplementation(() =>
+      Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listChats with default limit', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(20)
+    })
+
+    test('calls listChats with custom limit', async () => {
+      await chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(5)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('search subcommand', () => {
+    test('calls searchChats with query and default limit', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 20)
+    })
+
+    test('calls searchChats with query and custom limit', async () => {
+      await chatCommand.parseAsync(['search', 'General', '--limit', '3'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 3)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(1)
+    })
+  })
+
+  describe('get subcommand', () => {
+    test('calls getChat with chat reference', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(mockGetChat).toHaveBeenCalledWith('chat-1')
+    })
+
+    test('outputs JSON object to console', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe('chat-1')
+    })
+  })
+})

package/src/platforms/telegram/commands/message.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListMessages = mock(() =>
+  Promise.resolve([
+    { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+    { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+  ]),
+)
+
+const mockSendMessage = mock(() =>
+  Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+)
+
+const mockClient = {
+  listMessages: mockListMessages,
+  sendMessage: mockSendMessage,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { messageCommand } from './message'
+
+describe('message commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListMessages.mockReset()
+    mockListMessages.mockImplementation(() =>
+      Promise.resolve([
+        { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+        { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+      ]),
+    )
+    mockSendMessage.mockReset()
+    mockSendMessage.mockImplementation(() =>
+      Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listMessages with chat reference and default limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 20)
+    })
+
+    test('calls listMessages with custom limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--limit', '10'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 10)
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('send subcommand', () => {
+    test('calls sendMessage with chat reference and text', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'Hello there')
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe(3)
+    })
+  })
+})

package/src/platforms/webex/client.ts

@@ -1,6 +1,7 @@
 import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from './types'
 import { WebexError } from './types'
 import { WebexCredentialManager } from './credential-manager'
+import { WebexEncryptionService } from './encryption'
 
 const BASE_URL = 'https://webexapis.com/v1'
 const MAX_RETRIES = 3
@@ -17,6 +18,7 @@ export class WebexClient {
   private tokenType: string | null = null
   private buckets: Map<string, RateLimitBucket> = new Map()
   private globalRateLimitUntil: number = 0
+  private encryption: WebexEncryptionService | null = null
 
   async login(credentials?: { token: string }): Promise<this> {
     if (credentials) {
@@ -40,7 +42,16 @@ export class WebexClient {
     }
     this.deviceUrl = config?.deviceUrl ?? null
     this.tokenType = config?.tokenType ?? null
-    return this.login({ token })
+    await this.login({ token })
+
+    if (this.tokenType === 'extracted' && config?.encryptionKeys) {
+      const keysMap = new Map(Object.entries(config.encryptionKeys))
+      if (keysMap.size > 0) {
+        this.encryption = new WebexEncryptionService(keysMap)
+      }
+    }
+
+    return this
   }
 
   private ensureAuth(): string {
@@ -210,7 +221,7 @@ export class WebexClient {
   private async internalRequest<T>(path: string, init?: RequestInit): Promise<T> {
     const response = await fetch(`${this.convBaseUrl}${path}`, {
       ...init,
-      headers: { ...this.internalHeaders, ...init?.headers as Record<string, string> },
+      headers: { ...this.internalHeaders, ...(init?.headers as Record<string, string>) },
     })
 
     if (!response.ok) {
@@ -225,35 +236,78 @@ export class WebexClient {
     return response.json() as Promise<T>
   }
 
-  private activityToMessage(a: InternalActivity, roomId: string): WebexMessage {
+  private async activityToMessage(a: InternalActivity, roomId: string): Promise<WebexMessage> {
+    let text = a.object?.content ?? a.object?.displayName
+
+    if (this.encryption && text?.startsWith('eyJ')) {
+      const keyUrl = a.encryptionKeyUrl ?? a.object?.encryptionKeyUrl
+      if (keyUrl) {
+        const decrypted = await this.encryption.decryptText(keyUrl, text)
+        if (decrypted !== null) {
+          text = decrypted
+        }
+      }
+    }
+
     return {
       id: a.id,
       roomId,
       roomType: 'group' as const,
-      text: a.object?.content ?? a.object?.displayName,
+      text,
       personId: a.actor?.entryUUID ?? a.actor?.id ?? '',
       personEmail: a.actor?.emailAddress ?? '',
       created: a.published,
     }
   }
 
+  private async buildEncryptedObject(
+    convUuid: string,
+    text: string,
+    options?: { markdown?: boolean },
+  ): Promise<{ object: Record<string, string>; encryptionKeyUrl?: string }> {
+    const buildObject = (content: string): Record<string, string> =>
+      options?.markdown
+        ? { objectType: 'comment', displayName: content, content, markdown: content }
+        : { objectType: 'comment', displayName: content, content }
+
+    if (this.encryption) {
+      const conv = await this.internalRequest<InternalConversation>(
+        `/conversations/${convUuid}?activitiesLimit=0&participantsLimit=0`,
+      )
+      const keyUri = conv.defaultActivityEncryptionKeyUrl
+      if (keyUri) {
+        const encrypted = await this.encryption.encryptText(keyUri, text)
+        if (encrypted) {
+          return { object: buildObject(encrypted), encryptionKeyUrl: keyUri }
+        }
+      }
+    }
+
+    return { object: buildObject(text) }
+  }
+
   private async sendMessageInternal(
     roomId: string,
     text: string,
     options?: { markdown?: boolean },
   ): Promise<WebexMessage> {
     const convUuid = this.decodeConvUuid(roomId)
-    const object = options?.markdown
-      ? { objectType: 'comment', displayName: text, content: text, markdown: text }
-      : { objectType: 'comment', displayName: text, content: text }
+    const { object, encryptionKeyUrl } = await this.buildEncryptedObject(convUuid, text, options)
+
+    const activity: Record<string, unknown> = {
+      verb: 'post',
+      object,
+      target: { id: convUuid, objectType: 'conversation' },
+      clientTempId: `tmp-${Date.now()}`,
+    }
+
+    if (encryptionKeyUrl) {
+      activity['encryptionKeyUrl'] = encryptionKeyUrl
+    }
+
     const result = await this.internalRequest<InternalActivity>('/activities', {
       method: 'POST',
-      body: JSON.stringify({
-        verb: 'post',
-        object,
-        target: { id: convUuid, objectType: 'conversation' },
-        clientTempId: `tmp-${Date.now()}`,
-      }),
+      body: JSON.stringify(activity),
     })
     return this.activityToMessage(result, roomId)
   }
@@ -297,9 +351,8 @@ export class WebexClient {
       const conv = await this.internalRequest<InternalConversation>(
         `/conversations/${convUuid}?activitiesLimit=${max}&participantsLimit=0`,
       )
-      return (conv.activities?.items ?? [])
-        .filter((a) => a.verb === 'post')
-        .map((a) => this.activityToMessage(a, roomId))
+      const activities = (conv.activities?.items ?? []).filter((a) => a.verb === 'post')
+      return Promise.all(activities.map((a) => this.activityToMessage(a, roomId)))
     }
     const params = new URLSearchParams()
     params.set('roomId', roomId)
@@ -312,7 +365,9 @@ export class WebexClient {
     if (this.useInternalAPI) {
       const activity = await this.internalRequest<InternalActivity>(`/activities/${messageId}`)
       const convId = activity.target?.id ?? ''
-      const roomId = convId ? Buffer.from(`ciscospark://urn:TEAM:unknown/ROOM/${convId}`).toString('base64') : ''
+      const roomId = convId
+        ? Buffer.from(`ciscospark://urn:TEAM:unknown/ROOM/${convId}`).toString('base64')
+        : ''
       return this.activityToMessage(activity, roomId)
     }
     return this.request<WebexMessage>('GET', `/messages/${messageId}`)
@@ -344,15 +399,23 @@ export class WebexClient {
   ): Promise<WebexMessage> {
     if (this.useInternalAPI) {
       const convUuid = this.decodeConvUuid(roomId)
+      const { object, encryptionKeyUrl } = await this.buildEncryptedObject(convUuid, text, options)
+
+      const activity: Record<string, unknown> = {
+        verb: 'post',
+        object,
+        target: { id: convUuid, objectType: 'conversation' },
+        parent: { id: messageId, type: 'edit' },
+        clientTempId: `tmp-${Date.now()}`,
+      }
+
+      if (encryptionKeyUrl) {
+        activity['encryptionKeyUrl'] = encryptionKeyUrl
+      }
+
       const result = await this.internalRequest<InternalActivity>('/activities', {
         method: 'POST',
-        body: JSON.stringify({
-          verb: 'post',
-          object: { objectType: 'comment', displayName: text, content: text },
-          target: { id: convUuid, objectType: 'conversation' },
-          parent: { id: messageId, type: 'edit' },
-          clientTempId: `tmp-${Date.now()}`,
-        }),
+        body: JSON.stringify(activity),
       })
       return this.activityToMessage(result, roomId)
     }
@@ -394,12 +457,21 @@ interface InternalActivity {
   id: string
   verb: string
   actor?: { displayName?: string; emailAddress?: string; entryUUID?: string; id?: string }
-  object?: { content?: string; displayName?: string; objectType?: string }
-  target?: { id: string }
+  object?: {
+    content?: string
+    displayName?: string
+    objectType?: string
+    encryptionKeyUrl?: string
+  }
+  target?: { id: string; encryptionKeyUrl?: string }
   published: string
+  encryptionKeyUrl?: string
 }
 
 interface InternalConversation {
   id: string
   activities?: { items: InternalActivity[] }
+  defaultActivityEncryptionKeyUrl?: string
+  kmsResourceObjectUrl?: string
+  encryptionKeyUrl?: string
 }

package/src/platforms/webex/commands/auth.ts

@@ -174,6 +174,10 @@ export async function extractAction(options: { pretty?: boolean; debug?: boolean
       expiresAt: extracted.expiresAt ?? 0,
       tokenType: 'extracted',
       deviceUrl: extracted.deviceUrl,
+      userId: extracted.userId,
+      encryptionKeys: extracted.encryptionKeys
+        ? Object.fromEntries(extracted.encryptionKeys)
+        : undefined,
     })
 
     console.log(