agent-messenger 2.13.0 → 2.14.0

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

@@ -13,6 +13,7 @@ const mockGetAllMembers = mock(() => Promise.resolve({}))
 const mockGetMembersByIds = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
+const mockMarkRead = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
 const mockOnClose = mock((_handler: () => void) => {})
 const mockOnPush = mock((_handler: (packet: unknown) => void) => {})
@@ -29,6 +30,7 @@ mock.module('./protocol/session', () => ({
     getMembersByIds = mockGetMembersByIds
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
+    markRead = mockMarkRead
     close = mockClose
     onClose = mockOnClose
     onPush = mockOnPush
@@ -50,6 +52,7 @@ function resetAllMocks() {
   mockGetMembersByIds.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
+  mockMarkRead.mockReset()
   mockClose.mockReset()
   mockOnClose.mockReset()
   mockOnPush.mockReset()
@@ -910,6 +913,174 @@ describe('KakaoTalkClient', () => {
     })
   })
 
+  describe('markRead', () => {
+    it('calls session.markRead with parsed chatId/watermark and no linkId for normal chat', async () => {
+      // given
+      mockMarkRead.mockResolvedValueOnce({ statusCode: 0, body: { status: 0 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      const result = await client.markRead('100', '42')
+
+      // then
+      expect(mockMarkRead).toHaveBeenCalledTimes(1)
+      const [chatIdArg, watermarkArg, linkIdArg] = mockMarkRead.mock.calls[0] as [
+        { toString(): string },
+        { toString(): string },
+        unknown,
+      ]
+      expect(chatIdArg.toString()).toBe('100')
+      expect(watermarkArg.toString()).toBe('42')
+      expect(linkIdArg).toBeUndefined()
+      expect(result).toEqual({ success: true, status_code: 0, chat_id: '100', watermark: '42' })
+
+      client.close()
+    })
+
+    it('forwards linkId when caller passes it (open chat)', async () => {
+      // given
+      mockMarkRead.mockResolvedValueOnce({ statusCode: 0, body: { status: 0 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      await client.markRead('200', '999', { linkId: '77777' })
+
+      // then
+      const [, , linkIdArg] = mockMarkRead.mock.calls[0] as [unknown, unknown, { toString(): string }]
+      expect(linkIdArg).toBeDefined()
+      expect(linkIdArg.toString()).toBe('77777')
+
+      client.close()
+    })
+
+    it('reports success when body.status is absent (treated as 0)', async () => {
+      // given
+      mockMarkRead.mockResolvedValueOnce({ statusCode: 0, body: {} })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      const result = await client.markRead('100', '42')
+
+      // then
+      expect(result).toEqual({ success: true, status_code: 0, chat_id: '100', watermark: '42' })
+
+      client.close()
+    })
+
+    it('reports failure from body.status (not transport statusCode) - the open-chat-missing-link case', async () => {
+      // given
+      mockMarkRead.mockResolvedValueOnce({ statusCode: 0, body: { status: -500 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      const result = await client.markRead('100', '42')
+
+      // then
+      expect(result).toEqual({ success: false, status_code: -500, chat_id: '100', watermark: '42' })
+
+      client.close()
+    })
+
+    it('throws (so executeWithReconnect retries) on transport-level statusCode != 0', async () => {
+      // given - simulates LocoConnection.handleClose synthetic packet
+      mockMarkRead.mockRejectedValue(new Error('NOTIREAD failed: statusCode=-1'))
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('100', '42')
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('mark_read_failed')
+      }
+
+      client.close()
+    })
+
+    it('treats synthetic disconnect packet (statusCode: -1) as transport failure (throws)', async () => {
+      // given
+      mockMarkRead.mockResolvedValueOnce({ statusCode: -1, body: { error: 'connection closed' } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('100', '42')
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('mark_read_failed')
+      }
+
+      client.close()
+    })
+
+    it('throws KakaoTalkError(invalid_chat_id) for non-numeric chatId', async () => {
+      // given
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('not-a-number', '42')
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_chat_id')
+      }
+
+      client.close()
+    })
+
+    it('throws KakaoTalkError(invalid_log_id) for non-numeric logId', async () => {
+      // given
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('100', 'not-a-number')
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_log_id')
+      }
+
+      client.close()
+    })
+
+    it('throws KakaoTalkError(invalid_link_id) for non-numeric linkId', async () => {
+      // given
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('100', '42', { linkId: 'not-a-number' })
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('invalid_link_id')
+      }
+
+      client.close()
+    })
+
+    it('wraps transport errors as KakaoTalkError(mark_read_failed)', async () => {
+      // given
+      mockMarkRead.mockRejectedValue(new Error('Socket closed'))
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when / then
+      try {
+        await client.markRead('100', '42')
+        throw new Error('expected to throw')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('mark_read_failed')
+      }
+
+      client.close()
+    })
+  })
+
   describe('getMembers / getMembersByIds', () => {
     it('returns formatted members from GETMEM with normalized fields', async () => {
       mockGetAllMembers.mockResolvedValueOnce({

package/src/platforms/kakaotalk/client.ts

@@ -10,7 +10,15 @@ import { warn } from '@/shared/utils/stderr'
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
 import { LocoSession } from './protocol/session'
 import type { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
-import type { KakaoChat, KakaoDeviceType, KakaoMember, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
+import type {
+  KakaoChat,
+  KakaoDeviceType,
+  KakaoMarkReadResult,
+  KakaoMember,
+  KakaoMessage,
+  KakaoProfile,
+  KakaoSendResult,
+} from './types'
 
 export type KakaoSessionEvent =
   | { type: 'connected'; userId: string }
@@ -128,6 +136,22 @@ function parseUserId(userId: string): Long {
   }
 }
 
+function parseLogId(logId: string): Long {
+  try {
+    return parseLong(logId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid logId: ${logId}`, 'invalid_log_id', { cause })
+  }
+}
+
+function parseLinkId(linkId: string): Long {
+  try {
+    return parseLong(linkId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid linkId: ${linkId}`, 'invalid_link_id', { cause })
+  }
+}
+
 function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameCache): KakaoChat {
   const memberNames = (chat.k ?? []) as string[]
   const lastLog = chat.l as Record<string, unknown> | null
@@ -858,6 +882,40 @@ export class KakaoTalkClient {
     })
   }
 
+  /**
+   * Advance the read watermark for `chatId` up to and including `logId`.
+   * The caller decides open vs normal: pass `opts.linkId` for open chats
+   * (오픈채팅) and omit it for normal chats. Open chats without a `linkId`
+   * are rejected by the server with a non-zero `body.status` — this method
+   * does not auto-detect.
+   */
+  async markRead(chatId: string, logId: string, opts?: { linkId?: string }): Promise<KakaoMarkReadResult> {
+    const parsedChatId = parseChatId(chatId)
+    const parsedWatermark = parseLogId(logId)
+    const parsedLinkId = opts?.linkId !== undefined ? parseLinkId(opts.linkId) : undefined
+
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.markRead(parsedChatId, parsedWatermark, parsedLinkId)
+        // Throw on transport-level failure (incl. synthetic { statusCode: -1 }
+        // from LocoConnection.handleClose) so executeWithReconnect retries on
+        // a fresh session. The NOTIREAD command result lives in body.status.
+        if (response.statusCode !== 0) {
+          throw new Error(`NOTIREAD failed: statusCode=${response.statusCode}`)
+        }
+        const bodyStatus = typeof response.body.status === 'number' ? response.body.status : 0
+        return {
+          success: bodyStatus === 0,
+          status_code: bodyStatus,
+          chat_id: chatId,
+          watermark: logId,
+        }
+      } catch (error) {
+        throw wrapError(error, 'mark_read_failed')
+      }
+    })
+  }
+
   async getProfile(): Promise<KakaoProfile> {
     this.ensureAuth()
     try {

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

@@ -12,9 +12,16 @@ const mockGetMessages = mock(() =>
 
 const mockSendMessage = mock(() => Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }))
 
+const mockMarkRead = mock(() =>
+  Promise.resolve({ success: true, status_code: 0, chat_id: 'chat-123', watermark: '42' }),
+)
+
+const originalExit = process.exit
+
 const mockClient = {
   getMessages: mockGetMessages,
   sendMessage: mockSendMessage,
+  markRead: mockMarkRead,
 }
 
 mock.module('./shared', () => ({
@@ -30,6 +37,7 @@ describe('message commands', () => {
     mockWithKakaoClient.mockReset()
     mockGetMessages.mockReset()
     mockSendMessage.mockReset()
+    mockMarkRead.mockReset()
 
     mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
       return fn(mockClient)
@@ -38,6 +46,9 @@ describe('message commands', () => {
       Promise.resolve([{ log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 }]),
     )
     mockSendMessage.mockImplementation(() => Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }))
+    mockMarkRead.mockImplementation(() =>
+      Promise.resolve({ success: true, status_code: 0, chat_id: 'chat-123', watermark: '42' }),
+    )
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
@@ -45,6 +56,7 @@ describe('message commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    process.exit = originalExit
   })
 
   describe('list', () => {
@@ -101,4 +113,71 @@ describe('message commands', () => {
       )
     })
   })
+
+  describe('mark-read', () => {
+    it('calls markRead with chat-id and log-id, no opts for normal chat', async () => {
+      await messageCommand.parseAsync(['mark-read', 'chat-123', '42'], { from: 'user' })
+
+      expect(mockMarkRead).toHaveBeenCalledWith('chat-123', '42', undefined)
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual({ success: true, status_code: 0, chat_id: 'chat-123', watermark: '42' })
+    })
+
+    it('forwards --link-id when provided (open chat)', async () => {
+      await messageCommand.parseAsync(['mark-read', 'chat-123', '42', '--link-id', '77777'], { from: 'user' })
+
+      expect(mockMarkRead).toHaveBeenCalledWith('chat-123', '42', { linkId: '77777' })
+    })
+
+    it('--pretty prints pretty-formatted JSON (consistent with list/send)', async () => {
+      await messageCommand.parseAsync(['mark-read', 'chat-123', '42', '--pretty'], { from: 'user' })
+
+      const printed = consoleLogSpy.mock.calls[0][0] as string
+      expect(printed).toContain('\n')
+      expect(JSON.parse(printed)).toEqual({
+        success: true,
+        status_code: 0,
+        chat_id: 'chat-123',
+        watermark: '42',
+      })
+    })
+
+    it('exits non-zero when result.success is false (e.g. open chat missing --link-id)', async () => {
+      const exitSpy = mock((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+      process.exit = exitSpy as unknown as typeof process.exit
+      mockMarkRead.mockImplementationOnce(() =>
+        Promise.resolve({ success: false, status_code: -500, chat_id: 'chat-123', watermark: '42' }),
+      )
+
+      try {
+        await messageCommand.parseAsync(['mark-read', 'chat-123', '42'], { from: 'user' })
+      } catch {
+        // process.exit stub throws to abort the action
+      }
+
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+
+    it('exits zero on success', async () => {
+      const exitSpy = mock((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+      process.exit = exitSpy as unknown as typeof process.exit
+
+      await messageCommand.parseAsync(['mark-read', 'chat-123', '42'], { from: 'user' })
+
+      expect(exitSpy).not.toHaveBeenCalled()
+    })
+
+    it('passes account option to withKakaoClient', async () => {
+      await messageCommand.parseAsync(['mark-read', 'chat-123', '42', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+  })
 })

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

@@ -33,6 +33,24 @@ async function sendAction(
   }
 }
 
+async function markReadAction(
+  chatId: string,
+  logId: string,
+  options: { account?: string; linkId?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const result = await withKakaoClient(options, (client) =>
+      client.markRead(chatId, logId, options.linkId !== undefined ? { linkId: options.linkId } : undefined),
+    )
+    console.log(formatOutput(result, options.pretty))
+    if (!result.success) {
+      process.exit(1)
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const messageCommand = new Command('message')
   .description('KakaoTalk message commands')
   .addCommand(
@@ -54,3 +72,13 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('mark-read')
+      .description('Mark messages in a chat room as read up to a given log ID')
+      .argument('<chat-id>', 'Chat room ID')
+      .argument('<log-id>', 'Watermark log ID (mark messages up to and including this log_id as read)')
+      .option('--account <id>', 'Use a specific KakaoTalk account')
+      .option('--link-id <li>', 'Open-chat link ID (REQUIRED for open chats / 오픈채팅)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(markReadAction),
+  )

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

@@ -203,6 +203,20 @@ export class LocoSession {
     })
   }
 
+  /**
+   * Advance the server-side read watermark for a chat (NOTIREAD). Open chats
+   * supply `linkId`; normal chats must omit it (the wire `li` key must be
+   * absent, not null/0).
+   */
+  async markRead(chatId: Long, watermark: Long, linkId?: Long): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    const body: Record<string, unknown> = { chatId, watermark }
+    if (linkId !== undefined) {
+      body.li = linkId
+    }
+    return this.connection.sendPacket('NOTIREAD', body)
+  }
+
   onPush(handler: (packet: LocoPacket) => void): void {
     this.pushHandler = handler
     if (this.connection) {

package/src/platforms/kakaotalk/types.ts

@@ -118,6 +118,13 @@ export interface KakaoSendResult {
   sent_at: number
 }
 
+export interface KakaoMarkReadResult {
+  success: boolean
+  status_code: number
+  chat_id: string
+  watermark: string
+}
+
 export const KakaoChatSchema = z.object({
   chat_id: z.string(),
   type: z.number(),
@@ -166,6 +173,13 @@ export const KakaoSendResultSchema = z.object({
   sent_at: z.number(),
 })
 
+export const KakaoMarkReadResultSchema = z.object({
+  success: z.boolean(),
+  status_code: z.number(),
+  chat_id: z.string(),
+  watermark: z.string(),
+})
+
 export interface KakaoProfile {
   user_id: string
   nickname: string

package/src/platforms/slackbot/index.test.ts

@@ -5,8 +5,10 @@ import {
   SlackBotConfigSchema,
   SlackBotCredentialManager,
   SlackBotCredentialsSchema,
+  SlackBotEntrySchema,
   SlackBotError,
   SlackBotListener,
+  SlackBotWorkspaceSchema,
   SlackChannelSchema,
   SlackFileSchema,
   SlackMessageSchema,
@@ -38,6 +40,14 @@ it('SlackBotCredentialsSchema is exported from barrel', () => {
   expect(typeof SlackBotCredentialsSchema.parse).toBe('function')
 })
 
+it('SlackBotEntrySchema is exported from barrel', () => {
+  expect(typeof SlackBotEntrySchema.parse).toBe('function')
+})
+
+it('SlackBotWorkspaceSchema is exported from barrel', () => {
+  expect(typeof SlackBotWorkspaceSchema.parse).toBe('function')
+})
+
 it('SlackChannelSchema is exported from barrel', () => {
   expect(typeof SlackChannelSchema.parse).toBe('function')
 })

package/src/platforms/slackbot/index.ts

@@ -5,7 +5,9 @@ export type { SlackBotListenerOptions } from './listener'
 export type {
   SlackBotConfig,
   SlackBotCredentials,
+  SlackBotEntry,
   SlackBotListenerEventMap,
+  SlackBotWorkspace,
   SlackChannel,
   SlackFile,
   SlackMessage,
@@ -34,7 +36,9 @@ export type {
 export {
   SlackBotConfigSchema,
   SlackBotCredentialsSchema,
+  SlackBotEntrySchema,
   SlackBotError,
+  SlackBotWorkspaceSchema,
   SlackChannelSchema,
   SlackFileSchema,
   SlackMessageSchema,