agent-messenger 2.19.5 → 2.20.1

package/src/platforms/line/client.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, existsSync, mkdirSync } from 'node:fs'
+import { mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 
 import type { Operation as LineOperation } from '@jsr/evex__linejs-types'
@@ -13,6 +13,7 @@ import {
 } from '@/vendor/linejs/client/mod.js'
 
 import { LineCredentialManager } from './credential-manager'
+import { ensureSelfKeyForMid, migrateOwnE2EEKeys } from './e2ee-storage'
 import type {
   LineAccountCredentials,
   LineChat,
@@ -48,6 +49,8 @@ export interface LineRawMessage {
 
 export type LineRawEvent = { kind: 'message'; message: LineRawMessage } | { kind: 'event'; op: LineOperation }
 
+type VendorMessage = Parameters<Client['base']['e2ee']['decryptE2EEMessage']>[0]
+
 const MAX_MESSAGE_ID = 9223372036854775807n
 
 function wrapError(error: unknown, code: string): LineError {
@@ -89,17 +92,19 @@ function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
 
-function createStorage(accountId?: string): FileStorage {
+function lineStorageDir(): string {
   const dir = join(getConfigDir(), 'line-storage')
   mkdirSync(dir, { recursive: true })
-  const defaultPath = join(dir, 'default.json')
-  if (!accountId) return new FileStorage(defaultPath)
+  return dir
+}
 
-  const accountPath = join(dir, `${accountId}.json`)
-  if (!existsSync(accountPath) && existsSync(defaultPath)) {
-    copyFileSync(defaultPath, accountPath)
-  }
-  return new FileStorage(accountPath)
+// Per-account stores stay isolated: blindly cloning default.json would copy another
+// account's E2EE private keys into this account's file. E2EE key material is migrated
+// explicitly via migrateOwnE2EEKeys after login resolves the account MID.
+function createStorage(accountId?: string): FileStorage {
+  const dir = lineStorageDir()
+  const fileName = accountId ? `${accountId}.json` : 'default.json'
+  return new FileStorage(join(dir, fileName))
 }
 
 export class LineClient {
@@ -130,7 +135,7 @@ export class LineClient {
       this.client = client
 
       const profile = await client.base.talk.getProfile()
-      createStorage(profile.mid)
+      await this.persistAccountE2EEKeys(client, profile.mid)
       const now = new Date().toISOString()
 
       await this.credManager.setAccount({
@@ -176,7 +181,7 @@ export class LineClient {
       this.client = client
 
       const profile = await client.base.talk.getProfile()
-      createStorage(profile.mid)
+      await this.persistAccountE2EEKeys(client, profile.mid)
       const now = new Date().toISOString()
 
       await this.credManager.setAccount({
@@ -214,12 +219,38 @@ export class LineClient {
       const storage = createStorage(creds.account_id)
 
       this.client = await linejsLoginWithAuthToken(creds.auth_token, { device, storage })
+      await this.repairSelfE2EEKey(this.client, creds.account_id)
       return this
     } catch (error) {
       throw wrapError(error, 'login_failed')
     }
   }
 
+  // A fresh QR/email login writes E2EE keys into the shared default store. Copy only
+  // this account's verified key material into its isolated per-account store so token
+  // logins (which read the per-account store) can later encrypt for E2EE chats.
+  private async persistAccountE2EEKeys(client: Client, mid: string): Promise<void> {
+    try {
+      const advertised = await client.base.talk.getE2EEPublicKeys().catch(() => undefined)
+      const target = createStorage(mid)
+      await migrateOwnE2EEKeys(client.base.storage, target, mid, advertised)
+    } catch (error) {
+      warnDegraded('persist account E2EE keys', error)
+    }
+  }
+
+  // Token sessions don't perform an E2EE handshake, so getE2EESelfKeyData can't find
+  // a key under the account MID even when the keyId-addressed key already exists in
+  // storage. Promote it to the MID address, trusting only server-advertised keyIds.
+  private async repairSelfE2EEKey(client: Client, mid: string): Promise<void> {
+    try {
+      const advertised = await client.base.talk.getE2EEPublicKeys().catch(() => undefined)
+      await ensureSelfKeyForMid(client.base.storage, mid, advertised)
+    } catch (error) {
+      warnDegraded('repair self E2EE key', error)
+    }
+  }
+
   async getProfile(): Promise<LineProfile> {
     try {
       const profile = await this.ensureClient().base.talk.getProfile()
@@ -360,23 +391,86 @@ export class LineClient {
         },
       })
 
-      return (rawMessages ?? []).map((msg) => {
-        const decryptionError = getUndecryptableMessageError(msg)
-        return {
-          message_id: String(msg.id),
-          chat_id: chatId,
-          author_id: String(msg.from ?? ''),
-          text: msg.text || null,
-          ...(decryptionError && { decryption_error: decryptionError }),
-          content_type: String(msg.contentType ?? 'NONE'),
-          sent_at: new Date(Number(msg.createdTime)).toISOString(),
-        }
-      })
+      const messages = rawMessages ?? []
+      const authorNames = await this.resolveAuthorNames(client, messages)
+
+      return await Promise.all(
+        messages.map(async (msg) => {
+          const { text, decryptionError } = await this.decryptMessageText(client, msg)
+          const authorId = String(msg.from ?? '')
+          const authorName = authorNames.get(authorId)
+          return {
+            message_id: String(msg.id),
+            chat_id: chatId,
+            author_id: authorId,
+            ...(authorName && { author_name: authorName }),
+            text,
+            ...(decryptionError && { decryption_error: decryptionError }),
+            content_type: String(msg.contentType ?? 'NONE'),
+            sent_at: new Date(Number(msg.createdTime)).toISOString(),
+          }
+        }),
+      )
     } catch (error) {
       throw wrapError(error, 'get_messages_failed')
     }
   }
 
+  // getPreviousMessagesV2WithRequest returns Letter-Sealing messages as encrypted
+  // chunks with null text, so they must be decrypted with the same path streamEvents
+  // uses. Plain messages already carry text and skip decryption.
+  private async decryptMessageText(
+    client: Client,
+    msg: VendorMessage,
+  ): Promise<{ text: string | null; decryptionError?: LineDecryptionError }> {
+    if (!isEncryptedChunkMessage(msg)) {
+      return { text: msg.text || null }
+    }
+
+    try {
+      const decrypted = await client.base.e2ee.decryptE2EEMessage(normalizeE2EEMetadata(msg))
+      return { text: decrypted.text ?? null }
+    } catch (error) {
+      return { text: null, decryptionError: getDecryptionError(error) }
+    }
+  }
+
+  // getContacts doesn't return the current user, so self-authored messages need
+  // getProfile separately. Lookups degrade to bare MIDs rather than failing.
+  private async resolveAuthorNames(
+    client: Client,
+    messages: ReadonlyArray<{ from?: unknown }>,
+  ): Promise<Map<string, string>> {
+    const names = new Map<string, string>()
+    const authorMids = [...new Set(messages.map((m) => String(m.from ?? '')).filter((mid) => mid.length > 0))]
+    if (authorMids.length === 0) return names
+
+    const selfMid = client.base.profile?.mid
+    const contactMids = authorMids.filter((mid) => mid !== selfMid)
+
+    if (contactMids.length > 0) {
+      try {
+        const contacts = await client.base.talk.getContacts({ mids: contactMids })
+        for (const contact of contacts ?? []) {
+          if (contact.displayName) names.set(contact.mid, contact.displayName)
+        }
+      } catch (error) {
+        warnDegraded('resolve message author names', error)
+      }
+    }
+
+    if (selfMid && authorMids.includes(selfMid) && !names.has(selfMid)) {
+      try {
+        const profile = await client.base.talk.getProfile()
+        if (profile.displayName) names.set(selfMid, profile.displayName)
+      } catch (error) {
+        warnDegraded('resolve own display name', error)
+      }
+    }
+
+    return names
+  }
+
   async sendMessage(chatId: string, text: string): Promise<LineSendResult> {
     try {
       const client = this.ensureClient()
@@ -439,6 +533,12 @@ export class LineClient {
     })) {
       yield { kind: 'event', op }
       if (op.type === 'SEND_MESSAGE' || op.type === 'RECEIVE_MESSAGE') {
+        // Plain messages already carry their text and must skip decryption, same
+        // as the history path (decryptMessageText). Force-decrypting a plain op
+        // returns an object without `.text`, silently dropping the message to
+        // null text with no decryption_error — indistinguishable from an empty
+        // message downstream.
+        //
         // A single undecryptable message must not kill the stream: the failing
         // op stays in the sync window and would be re-fetched every poll, causing
         // an endless decrypt-fail -> reconnect loop. Fall back to the raw op and
@@ -446,12 +546,14 @@ export class LineClient {
         let raw = op.message
         let decrypted = true
         let decryptionError: LineDecryptionError | undefined
-        try {
-          raw = await client.base.e2ee.decryptE2EEMessage(op.message)
-        } catch (error) {
-          raw = op.message
-          decrypted = false
-          decryptionError = getDecryptionError(error)
+        if (isEncryptedChunkMessage(op.message)) {
+          try {
+            raw = await client.base.e2ee.decryptE2EEMessage(normalizeE2EEMetadata(op.message))
+          } catch (error) {
+            raw = op.message
+            decrypted = false
+            decryptionError = getDecryptionError(error)
+          }
         }
         decryptionError ??= getUndecryptableMessageError(raw)
         yield {
@@ -510,6 +612,16 @@ function isEncryptedChunkMessage(raw: unknown): boolean {
   return hasE2EEMetadata(message.contentMetadata) || hasE2EEMetadata(message.metadata)
 }
 
+// decryptE2EEMessage reads messageObj.contentMetadata.e2eeVersion unconditionally.
+// History messages from getPreviousMessagesV2WithRequest may carry E2EE metadata
+// only under `metadata`, which would crash the decryptor on undefined.e2eeVersion.
+function normalizeE2EEMetadata<T extends VendorMessage>(msg: T): T {
+  const m = msg as { contentMetadata?: unknown; metadata?: unknown }
+  if (hasE2EEMetadata(m.contentMetadata)) return msg
+  if (!hasE2EEMetadata(m.metadata)) return msg
+  return { ...msg, contentMetadata: m.metadata }
+}
+
 function hasE2EEMetadata(raw: unknown): boolean {
   if (!raw || typeof raw !== 'object') return false
   const metadata = raw as { e2eeMark?: unknown; e2eeVersion?: unknown }

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

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'bun:test'
+
+import { ensureSelfKeyForMid, migrateOwnE2EEKeys } from './e2ee-storage'
+
+function memStore(initial: Record<string, string> = {}) {
+  const data: Record<string, string> = { ...initial }
+  return {
+    data,
+    async get(key: string) {
+      return data[key]
+    },
+    async set(key: string, value: string) {
+      data[key] = value
+    },
+    async getAll() {
+      return { ...data }
+    },
+  }
+}
+
+const SELF_A = { keyId: 100, privKey: 'privA', pubKey: 'pubA', e2eeVersion: 2 }
+const SELF_B = { keyId: 200, privKey: 'privB', pubKey: 'pubB', e2eeVersion: 2 }
+
+describe('ensureSelfKeyForMid', () => {
+  it('keeps an existing MID-addressed self-key', async () => {
+    const store = memStore({ 'e2eeKeys:midA': JSON.stringify(SELF_A) })
+
+    const ok = await ensureSelfKeyForMid(store, 'midA', [{ keyId: 100 }])
+
+    expect(ok).toBe(true)
+    expect(JSON.parse(store.data['e2eeKeys:midA'])).toMatchObject({ privKey: 'privA' })
+  })
+
+  it('promotes a keyId-addressed self-key when the server advertises that keyId', async () => {
+    const store = memStore({ 'e2eeKeys:100': JSON.stringify(SELF_A) })
+
+    const ok = await ensureSelfKeyForMid(store, 'midA', [{ keyId: 100 }])
+
+    expect(ok).toBe(true)
+    expect(JSON.parse(store.data['e2eeKeys:midA'])).toMatchObject({ privKey: 'privA' })
+  })
+
+  it('supports the array-shaped public key (keyId at index 2)', async () => {
+    const store = memStore({ 'e2eeKeys:100': JSON.stringify(SELF_A) })
+
+    const ok = await ensureSelfKeyForMid(store, 'midA', [[undefined, undefined, 100] as never])
+
+    expect(ok).toBe(true)
+  })
+
+  it('never promotes a foreign-MID-addressed key (no advertised match)', async () => {
+    // given: storage contaminated with another account's self-key under its MID
+    const store = memStore({ 'e2eeKeys:midB': JSON.stringify(SELF_B) })
+
+    // when: account A has no advertised keyId matching any stored key
+    const ok = await ensureSelfKeyForMid(store, 'midA', [{ keyId: 999 }])
+
+    // then: A's MID key is not created from B's material
+    expect(ok).toBe(false)
+    expect(store.data['e2eeKeys:midA']).toBeUndefined()
+  })
+
+  it('never promotes a keyId key the server did not advertise for this account', async () => {
+    const store = memStore({ 'e2eeKeys:200': JSON.stringify(SELF_B) })
+
+    const ok = await ensureSelfKeyForMid(store, 'midA', [{ keyId: 100 }])
+
+    expect(ok).toBe(false)
+    expect(store.data['e2eeKeys:midA']).toBeUndefined()
+  })
+
+  it('rejects a payload whose own keyId does not match the advertised slot', async () => {
+    // given: the slot e2eeKeys:100 holds a payload that claims keyId 999
+    const mislabeled = { keyId: 999, privKey: 'privX', pubKey: 'pubX', e2eeVersion: 2 }
+    const store = memStore({ 'e2eeKeys:100': JSON.stringify(mislabeled) })
+
+    const ok = await ensureSelfKeyForMid(store, 'midA', [{ keyId: 100 }])
+
+    expect(ok).toBe(false)
+    expect(store.data['e2eeKeys:midA']).toBeUndefined()
+  })
+
+  it('returns false when no keys exist', async () => {
+    const store = memStore()
+    expect(await ensureSelfKeyForMid(store, 'midA', [{ keyId: 100 }])).toBe(false)
+  })
+
+  it('returns false for an empty mid', async () => {
+    const store = memStore({ 'e2eeKeys:100': JSON.stringify(SELF_A) })
+    expect(await ensureSelfKeyForMid(store, '', [{ keyId: 100 }])).toBe(false)
+  })
+})
+
+describe('migrateOwnE2EEKeys', () => {
+  it('copies only the advertised keyId material into the target', async () => {
+    const source = memStore({
+      'e2eeKeys:100': JSON.stringify(SELF_A),
+      'e2eePublicKeys:100': 'pubkey-blob-A',
+      'e2eeKeys:200': JSON.stringify(SELF_B),
+      'e2eePublicKeys:200': 'pubkey-blob-B',
+    })
+    const target = memStore()
+
+    const count = await migrateOwnE2EEKeys(source, target, 'midA', [{ keyId: 100 }])
+
+    expect(count).toBe(1)
+    expect(JSON.parse(target.data['e2eeKeys:100'])).toMatchObject({ privKey: 'privA' })
+    expect(target.data['e2eePublicKeys:100']).toBe('pubkey-blob-A')
+    // foreign account B keys must not leak across
+    expect(target.data['e2eeKeys:200']).toBeUndefined()
+    expect(target.data['e2eePublicKeys:200']).toBeUndefined()
+  })
+
+  it('copies the MID-addressed self-key when present', async () => {
+    const source = memStore({ 'e2eeKeys:midA': JSON.stringify(SELF_A) })
+    const target = memStore()
+
+    const count = await migrateOwnE2EEKeys(source, target, 'midA', [])
+
+    expect(count).toBe(1)
+    expect(JSON.parse(target.data['e2eeKeys:midA'])).toMatchObject({ privKey: 'privA' })
+  })
+
+  it('migrates nothing when only foreign keys are present', async () => {
+    const source = memStore({ 'e2eeKeys:midB': JSON.stringify(SELF_B), 'e2eeKeys:200': JSON.stringify(SELF_B) })
+    const target = memStore()
+
+    const count = await migrateOwnE2EEKeys(source, target, 'midA', [{ keyId: 100 }])
+
+    expect(count).toBe(0)
+    expect(Object.keys(target.data)).toHaveLength(0)
+  })
+
+  it('skips a payload whose own keyId does not match the advertised slot', async () => {
+    const mislabeled = { keyId: 999, privKey: 'privX', pubKey: 'pubX', e2eeVersion: 2 }
+    const source = memStore({ 'e2eeKeys:100': JSON.stringify(mislabeled), 'e2eePublicKeys:100': 'blob' })
+    const target = memStore()
+
+    const count = await migrateOwnE2EEKeys(source, target, 'midA', [{ keyId: 100 }])
+
+    expect(count).toBe(0)
+    expect(target.data['e2eeKeys:100']).toBeUndefined()
+    expect(target.data['e2eePublicKeys:100']).toBeUndefined()
+  })
+
+  it('ignores malformed key entries', async () => {
+    const source = memStore({ 'e2eeKeys:100': 'not-json', 'e2eeKeys:midA': '{"keyId":1}' })
+    const target = memStore()
+
+    const count = await migrateOwnE2EEKeys(source, target, 'midA', [{ keyId: 100 }])
+
+    expect(count).toBe(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' })