agent-messenger 2.32.2 → 2.33.0

package/src/platforms/discord/commands/member.test.ts

@@ -2,11 +2,52 @@ import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { meAction } from './member'
 
+let clientGetMyGuildMemberSpy: ReturnType<typeof spyOn>
+let clientListRolesSpy: ReturnType<typeof spyOn>
 let clientSearchMembersSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
+  clientGetMyGuildMemberSpy = spyOn(DiscordClient.prototype, 'getMyGuildMember').mockResolvedValue({
+    user: {
+      id: 'user-1',
+      username: 'alice',
+      global_name: 'Alice Smith',
+      avatar: 'avatar-hash-1',
+      bot: false,
+    },
+    nick: 'AliceNick',
+    roles: ['role-low', 'role-missing', 'role-high'],
+    joined_at: '2024-01-15T10:00:00Z',
+    deaf: false,
+    mute: false,
+    flags: 0,
+  })
+  clientListRolesSpy = spyOn(DiscordClient.prototype, 'listRoles').mockResolvedValue([
+    {
+      id: 'role-low',
+      name: 'Member',
+      color: 0,
+      hoist: false,
+      position: 1,
+      permissions: '1024',
+      managed: false,
+      mentionable: false,
+    },
+    {
+      id: 'role-high',
+      name: 'Admin',
+      color: 16711680,
+      hoist: true,
+      position: 10,
+      permissions: '8',
+      managed: false,
+      mentionable: true,
+    },
+  ])
   clientSearchMembersSpy = spyOn(DiscordClient.prototype, 'searchMembers').mockResolvedValue([
     {
       user: {
@@ -47,10 +88,14 @@ beforeEach(() => {
       'guild-1': { server_id: 'guild-1', server_name: 'Test Guild' },
     },
   })
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
+  clientGetMyGuildMemberSpy?.mockRestore()
+  clientListRolesSpy?.mockRestore()
   clientSearchMembersSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
   credManagerLoadSpy?.mockRestore()
 })
 
@@ -97,3 +142,135 @@ it('search: uses default limit of 10', async () => {
 
   expect(members).toHaveLength(2)
 })
+
+it("me: returns the current user's member object", async () => {
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output).toMatchObject({
+    user: {
+      id: 'user-1',
+      username: 'alice',
+      global_name: 'Alice Smith',
+      avatar: 'avatar-hash-1',
+      bot: false,
+    },
+    nick: 'AliceNick',
+    joined_at: '2024-01-15T10:00:00Z',
+    deaf: false,
+    mute: false,
+    flags: 0,
+  })
+  expect(clientGetMyGuildMemberSpy).toHaveBeenCalledWith('guild-1')
+  expect(clientListRolesSpy).toHaveBeenCalledWith('guild-1')
+})
+
+it('me: returns roles resolved to names (not raw IDs)', async () => {
+  await meAction('guild-2', {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.roles.map((role: { name: string }) => role.name)).toEqual(['Admin', 'Member'])
+  expect(output.roles).not.toContain('role-high')
+  expect(clientGetMyGuildMemberSpy).toHaveBeenCalledWith('guild-2')
+})
+
+it('me: roles are sorted by position descending', async () => {
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.roles.map((role: { position: number }) => role.position)).toEqual([10, 1])
+})
+
+it('me: role IDs with no matching role definition are dropped', async () => {
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.roles).toHaveLength(2)
+  expect(output.roles.map((role: { id: string }) => role.id)).not.toContain('role-missing')
+})
+
+it('me: breaks equal-position ties by snowflake, ranking the smaller ID higher', async () => {
+  // given two roles sharing a position whose IDs collide once coerced to Number
+  clientGetMyGuildMemberSpy.mockResolvedValue({
+    user: { id: 'user-1', username: 'alice', global_name: 'Alice Smith', avatar: 'avatar-hash-1', bot: false },
+    nick: null,
+    roles: ['1234567890123456789', '1234567890123456788'],
+    joined_at: '2024-01-15T10:00:00Z',
+    deaf: false,
+    mute: false,
+    flags: 0,
+  })
+  clientListRolesSpy.mockResolvedValue([
+    {
+      id: '1234567890123456789',
+      name: 'Newer',
+      color: 0,
+      position: 5,
+      hoist: false,
+      managed: false,
+      mentionable: false,
+      permissions: '0',
+    },
+    {
+      id: '1234567890123456788',
+      name: 'Older',
+      color: 0,
+      position: 5,
+      hoist: false,
+      managed: false,
+      mentionable: false,
+      permissions: '0',
+    },
+  ])
+
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.roles.map((role: { name: string }) => role.name)).toEqual(['Older', 'Newer'])
+})
+
+it('me: ranks by position before falling back to the snowflake', async () => {
+  clientGetMyGuildMemberSpy.mockResolvedValue({
+    user: { id: 'user-1', username: 'alice', global_name: 'Alice Smith', avatar: 'avatar-hash-1', bot: false },
+    nick: null,
+    roles: ['100', '200'],
+    joined_at: '2024-01-15T10:00:00Z',
+    deaf: false,
+    mute: false,
+    flags: 0,
+  })
+  clientListRolesSpy.mockResolvedValue([
+    {
+      id: '100',
+      name: 'Low',
+      color: 0,
+      position: 1,
+      hoist: false,
+      managed: false,
+      mentionable: false,
+      permissions: '0',
+    },
+    {
+      id: '200',
+      name: 'High',
+      color: 0,
+      position: 9,
+      hoist: false,
+      managed: false,
+      mentionable: false,
+      permissions: '0',
+    },
+  ])
+
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.roles.map((role: { name: string }) => role.name)).toEqual(['High', 'Low'])
+})
+
+it('me: preserves the raw role IDs even when a definition is unresolvable', async () => {
+  await meAction(undefined, {})
+
+  const output = JSON.parse(consoleLogSpy.mock.calls.at(-1)?.[0] as string)
+  expect(output.role_ids).toEqual(['role-low', 'role-missing', 'role-high'])
+})

package/src/platforms/discord/commands/member.ts

@@ -5,6 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import type { DiscordRole } from '../types'
 
 async function searchAction(
   guildId: string,
@@ -46,6 +47,80 @@ async function searchAction(
   }
 }
 
+export async function meAction(guildId: string | undefined, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const targetGuildId = guildId ?? config.current_server
+    if (!targetGuildId) {
+      console.log(formatOutput({ error: 'No current server set. Run "server switch <id>" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const [member, roles] = await Promise.all([client.getMyGuildMember(targetGuildId), client.listRoles(targetGuildId)])
+    const rolesById = new Map<string, DiscordRole>(roles.map((role) => [role.id, role]))
+    const resolvedRoles = member.roles
+      .map((roleId) => rolesById.get(roleId))
+      .filter((role): role is DiscordRole => role !== undefined)
+      .sort(compareRolesByHierarchy)
+      .map((role) => ({
+        id: role.id,
+        name: role.name,
+        color: role.color,
+        position: role.position,
+        hoist: role.hoist,
+        managed: role.managed,
+        mentionable: role.mentionable,
+        permissions: role.permissions,
+      }))
+
+    const output = {
+      user: {
+        id: member.user.id,
+        username: member.user.username,
+        global_name: member.user.global_name,
+        avatar: member.user.avatar,
+        bot: member.user.bot,
+      },
+      nick: member.nick,
+      role_ids: member.roles,
+      roles: resolvedRoles,
+      joined_at: member.joined_at,
+      deaf: member.deaf,
+      mute: member.mute,
+      flags: member.flags,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+// Discord ranks roles by descending position and breaks ties on the snowflake,
+// where the smaller ID is the higher role. Snowflakes exceed Number.MAX_SAFE_INTEGER,
+// so they are compared as BigInt rather than subtracted.
+function compareRolesByHierarchy(left: DiscordRole, right: DiscordRole): number {
+  if (left.position !== right.position) {
+    return right.position - left.position
+  }
+
+  const leftId = BigInt(left.id)
+  const rightId = BigInt(right.id)
+  if (leftId === rightId) {
+    return 0
+  }
+
+  return leftId < rightId ? -1 : 1
+}
+
 export const memberCommand = new Command('member')
   .description('Member commands')
   .addCommand(
@@ -57,3 +132,10 @@ export const memberCommand = new Command('member')
       .option('--pretty', 'Pretty print JSON output')
       .action(searchAction),
   )
+  .addCommand(
+    new Command('me')
+      .description('Get your own membership and roles in a guild')
+      .argument('[guild-id]', 'Guild ID (defaults to current server)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(meAction),
+  )

package/src/platforms/discord/index.ts

@@ -27,6 +27,9 @@ export type {
   DiscordReaction,
   DiscordReadState,
   DiscordRelationship,
+  DiscordRole,
+  DiscordRoleColors,
+  DiscordRoleTags,
   DiscordSearchOptions,
   DiscordSearchResponse,
   DiscordSearchResult,

package/src/platforms/discord/types.ts

@@ -207,6 +207,38 @@ export interface DiscordGuildMember {
   flags: number
 }
 
+export interface DiscordRoleColors {
+  primary_color: number
+  secondary_color: number | null
+  tertiary_color: number | null
+}
+
+export interface DiscordRoleTags {
+  bot_id?: string
+  integration_id?: string
+  premium_subscriber?: null
+  subscription_listing_id?: string
+  available_for_purchase?: null
+  guild_connections?: null
+}
+
+export interface DiscordRole {
+  id: string
+  name: string
+  /** @deprecated Discord still returns this; prefer {@link DiscordRoleColors.primary_color}. */
+  color: number
+  colors: DiscordRoleColors
+  hoist: boolean
+  position: number
+  permissions: string
+  managed: boolean
+  mentionable: boolean
+  flags: number
+  icon?: string | null
+  unicode_emoji?: string | null
+  tags?: DiscordRoleTags
+}
+
 export interface DiscordUserProfile {
   user: DiscordUser & { bio?: string }
   connected_accounts: Array<{

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

@@ -805,12 +805,12 @@ describe('KakaoTalkClient', () => {
 
   describe('getMessages', () => {
     it('falls back to SYNCMSG when MCHATLOGS succeeds with an empty result', async () => {
+      const loginResult = structuredClone(DEFAULT_LOGIN_RESULT)
+      loginResult.chatDatas[0]!.ll = makeLong(10)
+      mockLogin.mockResolvedValueOnce(loginResult)
       mockGetChatLogs.mockResolvedValueOnce({
         body: { status: 0, chatLogs: [], eof: true },
       })
-      mockGetChatInfo.mockResolvedValueOnce({
-        body: { status: 0, l: makeLong(10) },
-      })
       mockSyncMessages.mockResolvedValueOnce({
         body: {
           status: 0,
@@ -826,8 +826,100 @@ describe('KakaoTalkClient', () => {
 
       expect(messages).toHaveLength(1)
       expect(messages[0]?.message).toBe('fallback')
-      expect(mockGetChatInfo).toHaveBeenCalledTimes(1)
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
       expect(mockSyncMessages).toHaveBeenCalledTimes(1)
+      expect(mockSyncMessages.mock.calls[0]?.[3]?.toString()).toBe('10')
+
+      client.close()
+    })
+
+    it('does not enter or sync a room when the MCHATLOGS cursor is already current', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const messages = await client.getMessages('100', { from: '999' })
+
+      expect(messages).toEqual([])
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+      expect(mockSyncMessages).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('uses SYNCMSG without entering the room when the chat-list watermark is ahead of the cursor', async () => {
+      const loginResult = structuredClone(DEFAULT_LOGIN_RESULT)
+      loginResult.chatDatas[0]!.ll = makeLong(10)
+      mockLogin.mockResolvedValueOnce(loginResult)
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+      mockSyncMessages.mockResolvedValueOnce({
+        body: {
+          status: 0,
+          isOK: true,
+          chatLogs: [
+            { logId: makeLong(10), chatId: 100, type: 1, authorId: 42, message: 'incremental', sendAt: 1700000001 },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const messages = await client.getMessages('100', { from: '9' })
+
+      expect(messages).toHaveLength(1)
+      expect(messages[0]?.message).toBe('incremental')
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+      expect(mockSyncMessages.mock.calls[0]?.[2]?.toString()).toBe('9')
+      expect(mockSyncMessages.mock.calls[0]?.[3]?.toString()).toBe('10')
+
+      client.close()
+    })
+
+    it('uses the last-message log ID when the primary chat-list watermark is missing', async () => {
+      const loginResult = structuredClone(DEFAULT_LOGIN_RESULT)
+      const chat = loginResult.chatDatas[0]! as Record<string, unknown>
+      delete chat.ll
+      chat.l = { logId: makeLong(12) }
+      mockLogin.mockResolvedValueOnce(loginResult)
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+      mockSyncMessages.mockResolvedValueOnce({
+        body: {
+          status: 0,
+          isOK: true,
+          chatLogs: [
+            { logId: makeLong(12), chatId: 100, type: 1, authorId: 42, message: 'last-log', sendAt: 1700000001 },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const messages = await client.getMessages('100', { from: '11' })
+
+      expect(messages).toHaveLength(1)
+      expect(messages[0]?.message).toBe('last-log')
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+      expect(mockSyncMessages.mock.calls[0]?.[2]?.toString()).toBe('11')
+      expect(mockSyncMessages.mock.calls[0]?.[3]?.toString()).toBe('12')
+
+      client.close()
+    })
+
+    it('returns empty without entering the room when no chat-list watermark is available', async () => {
+      mockLogin.mockResolvedValueOnce({ ...structuredClone(DEFAULT_LOGIN_RESULT), chatDatas: [] })
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const messages = await client.getMessages('100')
+
+      expect(messages).toEqual([])
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+      expect(mockSyncMessages).not.toHaveBeenCalled()
 
       client.close()
     })

package/src/platforms/kakaotalk/client.ts

@@ -242,6 +242,14 @@ function getOpenLinkId(chat: ChatData): Long | null {
   return bsonToLong(chat.li) ?? null
 }
 
+function getLoginMaxLogId(loginResult: LoginListResponse, chatId: string): Long | null {
+  const chat = (loginResult.chatDatas ?? []).find((entry) => longToString(entry.c) === chatId)
+  if (!chat) return null
+
+  const lastLog = chat.l as Record<string, unknown> | null | undefined
+  return bsonToLong(chat.ll) ?? bsonToLong(lastLog?.logId) ?? null
+}
+
 function matchesSearch(chat: ChatData, term: string): boolean {
   const names = (chat.k ?? []) as string[]
   const lower = term.toLowerCase()
@@ -827,7 +835,7 @@ export class KakaoTalkClient {
   }
 
   async getMessages(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessage[]> {
-    return this.executeWithReconnect(async ({ session }) => {
+    return this.executeWithReconnect(async ({ session, loginResult }) => {
       try {
         const count = options?.count ?? 20
         const cursor = options?.from ? parseLong(options.from) : undefined
@@ -880,10 +888,13 @@ export class KakaoTalkClient {
           return formatMessages(allMessages, count, chatId, this.nameCache)
         }
 
-        // Fetch fresh lastLogId via CHATONROOM (not the stale login-time snapshot)
-        const chatInfo = await session.getChatInfo(cid)
-        const chatBody = chatInfo.body as Record<string, unknown>
-        const maxLogId = bsonToLong(chatBody.l)
+        // CHATONROOM represents entering a room and can advance unread state on
+        // the server. Use the login-time chat-list watermark for the read-only
+        // SYNCMSG fallback instead, and skip sync when the cursor is current.
+        const maxLogId = getLoginMaxLogId(loginResult, chatId)
+        if (!maxLogId || maxLogId.lessThanOrEqual(cur)) {
+          return []
+        }
 
         let reachedEnd = false
         for (let page = 0; page < MAX_PAGES; page++) {