agent-messenger 2.34.0 → 2.36.0

package/src/platforms/kakaotalk/protocol/session.ts

@@ -15,6 +15,7 @@ import {
   getLocoDeviceConfig,
 } from './config'
 import { LocoConnection } from './connection'
+import { validateLoginListResponse } from './login-response'
 import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket, SyncState } from './types'
 
 // LOCO opcode string emitted on the wire for typing indicator pulses.
@@ -81,27 +82,34 @@ export class LocoSession {
     const lastTokenId = syncState ? new Long(syncState.lastTokenId.low, syncState.lastTokenId.high) : Long.fromNumber(0)
     const lbk = syncState?.lbk ?? 0
 
-    const response = await this.connection.sendPacket('LOGINLIST', {
-      appVer: deviceConfig.appVersion,
-      prtVer: PROTOCOL_VERSION,
-      os: deviceConfig.os,
-      lang: LANG,
-      dtype: DTYPE,
-      duuid: deviceUuid,
-      oauthToken,
-      ntype: 0,
-      MCCMNC: MCCMNC,
-      revision: syncState?.revision ?? 0,
-      chatIds,
-      maxIds,
-      lastTokenId,
-      lbk,
-      rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
-      bg: false,
-    })
-
-    this.startPing()
-    return response.body as unknown as LoginListResponse
+    try {
+      const response = await this.connection.sendPacket('LOGINLIST', {
+        appVer: deviceConfig.appVersion,
+        prtVer: PROTOCOL_VERSION,
+        os: deviceConfig.os,
+        lang: LANG,
+        dtype: DTYPE,
+        duuid: deviceUuid,
+        oauthToken,
+        ntype: 0,
+        MCCMNC: MCCMNC,
+        revision: syncState?.revision ?? 0,
+        chatIds,
+        maxIds,
+        lastTokenId,
+        lbk,
+        rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
+        bg: false,
+      })
+
+      const loginResult = validateLoginListResponse(response)
+      this.startPing()
+      return loginResult
+    } catch (error) {
+      this.connection.close()
+      this.connection = null
+      throw error
+    }
   }
 
   private async bookAndCheckin(

package/src/platforms/kakaotalk/protocol/types.ts

@@ -36,6 +36,7 @@ export interface SyncState {
 
 // LOGINLIST uses short BSON field names: c=chatId, t=type, a=activeMembers, etc.
 export interface LoginListResponse extends ChatListResponse {
+  status?: number
   userId: number
   revision: number
 }

package/src/platforms/kakaotalk/types.ts

@@ -12,6 +12,7 @@ export interface ExtractedKakaoToken {
 }
 
 export type KakaoAuthMethod = 'login' | 'extract'
+export type KakaoAuthErrorCode = 'invalid_access_token' | 'login_rejected'
 
 export interface KakaoAccountCredentials {
   account_id: string

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

@@ -328,6 +328,38 @@ describe('TeamsClient', () => {
         }),
       )
     })
+
+    it('converts markdown to HTML when format is markdown', 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', '**bold** and `code`', 'markdown')
+
+      // The return value echoes the caller's original markdown, not the converted HTML
+      expect(message.content).toBe('**bold** and `code`')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<strong>bold</strong> and <code>code</code>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+        }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({ OriginalArrivalTime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      await client.sendChatMessage('19:1on1@unq.gbl.spaces', '<b>raw</b>', 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<b>raw</b>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+        }),
+      )
+    })
   })
 
   describe('editChatMessage', () => {
@@ -352,6 +384,39 @@ describe('TeamsClient', () => {
         }),
       )
     })
+
+    it('converts markdown to HTML when format is markdown', async () => {
+      mockResponse({ edittime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const message = await client.editChatMessage('19:1on1@unq.gbl.spaces', 'msg1', '**bold**', 'markdown')
+
+      expect(message.content).toBe('**bold**')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<strong>bold</strong>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({ edittime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      await client.editChatMessage('19:1on1@unq.gbl.spaces', 'msg1', '<b>raw</b>', 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<b>raw</b>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
   })
 
   describe('getTeam', () => {
@@ -437,6 +502,68 @@ describe('TeamsClient', () => {
       expect(message.parent_message_id).toBe('root1')
       expect(message.is_thread_reply).toBe(true)
     })
+
+    it('escapes HTML in channel messages when format is text', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: 'a &lt;b&gt; &amp; c',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', 'a <b> & c')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'a &lt;b&gt; &amp; c' }))
+    })
+
+    it('converts markdown to HTML for channel messages', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: '<strong>bold</strong>',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', '**bold**', undefined, 'markdown')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: '<strong>bold</strong>' }))
+    })
+
+    it('converts markdown to HTML for channel thread replies', async () => {
+      mockResponse({
+        id: 'reply1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: '<strong>bold</strong>',
+        timestamp: '2024-01-01T00:01:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', '**bold**', 'root1', 'markdown')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({ content: '<strong>bold</strong>', parentMessageId: 'root1' }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: 'Hey <at id="29:xyz">John</at>',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', 'Hey <at id="29:xyz">John</at>', undefined, 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Hey <at id="29:xyz">John</at>' }))
+    })
   })
 
   describe('getMessages', () => {

package/src/platforms/teams/client.ts

@@ -2,8 +2,11 @@ import { randomUUID } from 'node:crypto'
 import { readFile } from 'node:fs/promises'
 import { basename } from 'node:path'
 
+import { escapeHtml, markdownToHtml } from '@/shared/utils/markdown-to-html'
+
 import { SUBSTRATE_SEARCH_URL } from './app-config'
 import { TeamsCredentialManager } from './credential-manager'
+import { sanitizeTeamsHtml } from './html-sanitizer'
 import { TeamsTokenProvider } from './token-provider'
 import type {
   TeamsAccountType,
@@ -12,6 +15,7 @@ import type {
   TeamsChatType,
   TeamsFile,
   TeamsMessage,
+  TeamsMessageFormat,
   TeamsRegion,
   TeamsSearchResult,
   TeamsTeam,
@@ -230,13 +234,9 @@ async function readDownloadResponse(response: Response, codePrefix: string): Pro
   return Buffer.from(await response.arrayBuffer())
 }
 
-function escapeHtml(value: string): string {
-  return value
-    .replaceAll('&', '&')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&#39;')
+function formatContent(content: string, format: TeamsMessageFormat): string {
+  if (format === 'html') return sanitizeTeamsHtml(content)
+  return format === 'markdown' ? markdownToHtml(content) : escapeHtml(content)
 }
 
 function withThreadMetadata(message: RawTeamsMessage, rootMessageId?: string): TeamsMessage {
@@ -692,13 +692,13 @@ export class TeamsClient {
       }))
   }
 
-  async sendChatMessage(chatId: string, content: string): Promise<TeamsMessage> {
+  async sendChatMessage(chatId: string, content: string, format: TeamsMessageFormat = 'text'): 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),
+      content: formatContent(content, format),
       messagetype: 'RichText/Html',
       contenttype: 'text',
     })
@@ -713,7 +713,12 @@ export class TeamsClient {
     }
   }
 
-  async editChatMessage(chatId: string, messageId: string, content: string): Promise<TeamsMessage> {
+  async editChatMessage(
+    chatId: string,
+    messageId: string,
+    content: string,
+    format: TeamsMessageFormat = 'text',
+  ): Promise<TeamsMessage> {
     interface EditResponse {
       edittime?: string | number
     }
@@ -724,7 +729,7 @@ export class TeamsClient {
       'PUT',
       `/users/ME/conversations/${encodedChatId}/messages/${encodedMessageId}`,
       {
-        content: escapeHtml(content),
+        content: formatContent(content, format),
         messagetype: 'RichText/Html',
         contenttype: 'text',
         skypeeditedid: messageId,
@@ -758,12 +763,20 @@ export class TeamsClient {
     )
   }
 
-  async sendMessage(teamId: string, channelId: string, content: string, rootMessageId?: string): Promise<TeamsMessage> {
+  async sendMessage(
+    teamId: string,
+    channelId: string,
+    content: string,
+    rootMessageId?: string,
+    format: TeamsMessageFormat = 'text',
+  ): Promise<TeamsMessage> {
+    const body = formatContent(content, format)
+
     if (rootMessageId) {
       const response = await this.request<RawTeamsMessage>(
         'POST',
         `/csa/${this.region}/api/v2/teams/${teamId}/channels/${channelId}/messages/${rootMessageId}/replies`,
-        { content, parentMessageId: rootMessageId },
+        { content: body, parentMessageId: rootMessageId },
         CSA_API_BASE,
       )
       return withThreadMetadata(response, rootMessageId)
@@ -772,7 +785,7 @@ export class TeamsClient {
     return this.request<TeamsMessage>(
       'POST',
       `/csa/${this.region}/api/v2/teams/${teamId}/channels/${channelId}/messages`,
-      { content },
+      { content: body },
       CSA_API_BASE,
     )
   }

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

@@ -107,6 +107,7 @@ it('send: returns sent message', async () => {
   expect(consoleSpy).toHaveBeenCalled()
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Hello world')
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'Hello world', 'text')
 })
 
 it('edit: edits a chat message and returns updated content', async () => {
@@ -115,8 +116,76 @@ it('edit: edits a chat message and returns updated content', async () => {
 
   await editAction('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content', { pretty: false })
 
-  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content')
+  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content', 'text')
   expect(consoleSpy).toHaveBeenCalled()
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Edited content')
 })
+
+it('send: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('19:1on1@unq.gbl.spaces', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', '**bold**', 'markdown')
+})
+
+it('send: defaults to text format when --format is omitted', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('19:1on1@unq.gbl.spaces', 'plain', { pretty: false })
+
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'plain', 'text')
+})
+
+it('send: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(sendAction('19:1on1@unq.gbl.spaces', 'hi', { pretty: false, format: 'invalid' })).rejects.toThrow(
+      'exit:1',
+    )
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('Invalid format')
+    expect(clientSendChatMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})
+
+it('edit: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('19:1on1@unq.gbl.spaces', 'msg_123', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', '**bold**', 'markdown')
+})
+
+it('edit: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(
+      editAction('19:1on1@unq.gbl.spaces', 'msg_123', 'hi', { pretty: false, format: 'invalid' }),
+    ).rejects.toThrow('exit:1')
+
+    expect(clientEditChatMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})

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

@@ -5,6 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
+import { resolveFormat } from './format'
 
 export async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -70,7 +71,13 @@ export async function historyAction(chatId: string, options: { limit?: number; p
   }
 }
 
-export async function sendAction(chatId: string, content: string, options: { pretty?: boolean }): Promise<void> {
+export async function sendAction(
+  chatId: string,
+  content: string,
+  options: { pretty?: boolean; format?: string },
+): Promise<void> {
+  const format = resolveFormat(options.format, options.pretty)
+
   try {
     const credManager = new TeamsCredentialManager()
     const cred = await credManager.getTokenWithExpiry()
@@ -86,7 +93,7 @@ export async function sendAction(chatId: string, content: string, options: { pre
       accountType: cred.accountType,
       region: cred.region,
     })
-    const message = await client.sendChatMessage(chatId, content)
+    const message = await client.sendChatMessage(chatId, content, format)
 
     const output = {
       id: message.id,
@@ -104,8 +111,10 @@ export async function editAction(
   chatId: string,
   messageId: string,
   content: string,
-  options: { pretty?: boolean },
+  options: { pretty?: boolean; format?: string },
 ): Promise<void> {
+  const format = resolveFormat(options.format, options.pretty)
+
   try {
     const credManager = new TeamsCredentialManager()
     const cred = await credManager.getTokenWithExpiry()
@@ -121,7 +130,7 @@ export async function editAction(
       accountType: cred.accountType,
       region: cred.region,
     })
-    const message = await client.editChatMessage(chatId, messageId, content)
+    const message = await client.editChatMessage(chatId, messageId, content, format)
 
     const output = {
       id: message.id,
@@ -161,6 +170,7 @@ export const chatCommand = new Command('chat')
       .description('Send a message to a chat')
       .argument('<chat-id>', 'Chat ID')
       .argument('<content>', 'Message content')
+      .option('--format <format>', 'Message format: text, markdown, or html', 'text')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
@@ -170,6 +180,7 @@ export const chatCommand = new Command('chat')
       .argument('<chat-id>', 'Chat ID')
       .argument('<message-id>', 'Message ID')
       .argument('<content>', 'New message content')
+      .option('--format <format>', 'Message format: text, markdown, or html', 'text')
       .option('--pretty', 'Pretty print JSON output')
       .action(editAction),
   )

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

@@ -0,0 +1,12 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import type { TeamsMessageFormat } from '../types'
+
+export function resolveFormat(value: string | undefined, pretty: boolean | undefined): TeamsMessageFormat {
+  const format = value ?? 'text'
+  if (format !== 'text' && format !== 'markdown' && format !== 'html') {
+    console.log(formatOutput({ error: `Invalid format: ${format}. Use "text", "markdown", or "html".` }, pretty))
+    process.exit(1)
+  }
+  return format
+}

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

@@ -207,3 +207,59 @@ it('delete: returns success', async () => {
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('deleted')
 })
+
+it('send: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '**bold**', undefined, 'markdown')
+})
+
+it('send: defaults to text format when --format is omitted', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', 'plain', { pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', 'plain', undefined, 'text')
+})
+
+it('send: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(sendAction('team_123', 'ch_456', 'hi', { pretty: false, format: 'invalid' })).rejects.toThrow('exit:1')
+
+    expect(consoleSpy).toHaveBeenCalled()
+    expect(consoleSpy.mock.calls[0][0]).toContain('Invalid format')
+    expect(clientSendMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})
+
+it('send: passes html format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '<at id="29:x">John</at>', { pretty: false, format: 'html' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '<at id="29:x">John</at>', undefined, 'html')
+})
+
+it('send: passes markdown format together with --thread', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '**bold**', { pretty: false, thread: 'root_1', format: 'markdown' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '**bold**', 'root_1', 'markdown')
+})

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

@@ -7,13 +7,16 @@ import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
 import type { TeamsMessage } from '../types'
 import { TeamsAuthCapabilityError } from '../types'
+import { resolveFormat } from './format'
 
 export async function sendAction(
   teamId: string,
   channelId: string,
   content: string,
-  options: { pretty?: boolean; thread?: string },
+  options: { pretty?: boolean; thread?: string; format?: string },
 ): Promise<void> {
+  const format = resolveFormat(options.format, options.pretty)
+
   try {
     const credManager = new TeamsCredentialManager()
     const cred = await credManager.getTokenWithExpiry()
@@ -29,7 +32,7 @@ export async function sendAction(
       accountType: cred.accountType,
       region: cred.region,
     })
-    const message = await client.sendMessage(teamId, channelId, content, options.thread)
+    const message = await client.sendMessage(teamId, channelId, content, options.thread, format)
 
     const output = {
       id: message.id,
@@ -274,6 +277,7 @@ export const messageCommand = new Command('message')
       .argument('<channel-id>', 'Channel ID')
       .argument('<content>', 'Message content')
       .option('--thread <message-id>', 'Reply to a thread root message')
+      .option('--format <format>', 'Message format: text, markdown, or html', 'text')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )