agent-messenger 2.4.0 → 2.6.0

package/src/platforms/channeltalkbot/commands/whoami.ts

@@ -0,0 +1,42 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WorkspaceOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: string
+  name?: string
+  homepage_url?: string
+  description?: string
+  error?: string
+}
+
+export async function whoamiAction(options: WorkspaceOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const channel = await client.getChannel()
+    return {
+      id: channel.id,
+      name: channel.name,
+      homepage_url: channel.homepageUrl,
+      description: channel.description,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--workspace <id>', 'Workspace ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: WorkspaceOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/platforms/discord/cli.ts

@@ -20,6 +20,7 @@ import {
   snapshotCommand,
   threadCommand,
   userCommand,
+  whoamiCommand,
 } from './commands'
 import { ensureDiscordAuth } from './ensure-auth'
 
@@ -60,6 +61,7 @@ program.addCommand(reactionCommand)
 program.addCommand(snapshotCommand)
 program.addCommand(threadCommand)
 program.addCommand(userCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -13,3 +13,4 @@ export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
 export { threadCommand } from './thread'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import { DiscordClient } from '@/platforms/discord/client'
+import { DiscordCredentialManager } from '@/platforms/discord/credential-manager'
+import { whoamiAction, whoamiCommand } from '@/platforms/discord/commands/whoami'
+
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+const mockConfig = {
+  token: 'test-discord-token',
+}
+
+const mockUser = {
+  id: 'user123',
+  username: 'testuser',
+  global_name: 'Test User',
+  avatar: 'avatar_hash',
+  bot: false,
+}
+
+beforeEach(() => {
+  credManagerSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue(mockConfig)
+  clientTestAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue(mockUser)
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  credManagerSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+test('whoami command is defined with correct name and description', () => {
+  expect(whoamiCommand).toBeDefined()
+  expect(whoamiCommand.name()).toBe('whoami')
+  expect(whoamiCommand.description()).toBe('Show current authenticated user')
+})
+
+test('whoami command has --pretty option', () => {
+  const options = whoamiCommand.options
+  const hasPretty = options.some((opt: { long?: string }) => opt.long === '--pretty')
+  expect(hasPretty).toBe(true)
+})
+
+test('whoami outputs expected user fields', async () => {
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'user123',
+      username: 'testuser',
+      global_name: 'Test User',
+      avatar: 'avatar_hash',
+      bot: false,
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+  await whoamiAction({ pretty: true })
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'user123',
+        username: 'testuser',
+        global_name: 'Test User',
+        avatar: 'avatar_hash',
+        bot: false,
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with error when not authenticated', async () => {
+  credManagerSpy.mockResolvedValue({ token: undefined })
+
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({ error: 'Not authenticated. Run "auth extract" first.' }),
+  )
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

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

@@ -0,0 +1,36 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+export async function whoamiAction(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))
+      return process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      username: user.username,
+      global_name: user.global_name,
+      avatar: user.avatar,
+      bot: user.bot,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/discordbot/cli.ts

@@ -13,6 +13,7 @@ import {
   snapshotCommand,
   threadCommand,
   userCommand,
+  whoamiCommand,
 } from './commands/index'
 
 const program = new Command()
@@ -25,6 +26,7 @@ program
   .option('--server <id>', 'Server ID to use')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(serverCommand)
 program.addCommand(messageCommand)
 program.addCommand(channelCommand)

package/src/platforms/discordbot/commands/index.ts

@@ -7,3 +7,4 @@ export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
 export { threadCommand } from './thread'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

package/src/platforms/discordbot/commands/whoami.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockTestAuth = mock(() =>
+  Promise.resolve({
+    id: 'bot-user-id',
+    username: 'testbot',
+    global_name: 'Test Bot',
+    avatar: 'avatar123',
+    bot: true,
+  }),
+)
+
+mock.module('../client', () => ({
+  DiscordBotClient: class MockDiscordBotClient {
+    async login(_credentials?: any) {
+      return this
+    }
+    testAuth = mockTestAuth
+  },
+}))
+
+import { DiscordBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `discordbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_DISCORDBOT_TOKEN
+    mockTestAuth.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns auth info for current bot', async () => {
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'bot1',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.id).toBe('bot-user-id')
+    expect(result.username).toBe('testbot')
+    expect(result.global_name).toBe('Test Bot')
+    expect(result.avatar).toBe('avatar123')
+    expect(result.bot).toBe(true)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns auth info for specific --bot', async () => {
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    })
+
+    const result = await whoamiAction({ bot: 'deploy', _credManager: manager })
+
+    expect(result.id).toBe('bot-user-id')
+    expect(result.username).toBe('testbot')
+    expect(mockTestAuth).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'bot1',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})

package/src/platforms/discordbot/commands/whoami.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: string
+  username?: string
+  global_name?: string
+  avatar?: string
+  bot?: boolean
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.testAuth()
+    return {
+      id: info.id,
+      username: info.username,
+      global_name: info.global_name,
+      avatar: info.avatar,
+      bot: info.bot,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--bot <id>', 'Bot ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/platforms/instagram/cli.ts

@@ -4,7 +4,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureInstagramAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -31,6 +31,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

package/src/platforms/instagram/client.ts

@@ -410,6 +410,19 @@ export class InstagramClient {
     return this.userId
   }
 
+  async getProfile(): Promise<{ user_id: string; username: string; full_name: string | null; profile_pic_url: string | null }> {
+    if (!this.userId) {
+      throw new InstagramError('Not authenticated. Call login() first.', 'not_authenticated')
+    }
+    const account = await this.credentialManager.getAccount()
+    return {
+      user_id: this.userId,
+      username: account?.username ?? '',
+      full_name: account?.full_name ?? null,
+      profile_pic_url: account?.profile_pic_url ?? null,
+    }
+  }
+
   private async preLoginFlow(): Promise<{ keyId: string; publicKey: string } | null> {
     const url = `${IG_BASE_URL}/qe/sync/`
     const headers = this.buildHeaders()

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
@@ -34,10 +34,6 @@ function resetCommandState(cmd: Command): void {
   }
 }
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('chat commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>

package/src/platforms/instagram/commands/index.ts

@@ -1,3 +1,4 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
 export { messageCommand } from './message'
+export { whoamiCommand } from './whoami'

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
@@ -32,10 +32,6 @@ function resetCommandState(cmd: Command): void {
   }
 }
 
-afterAll(() => {
-  mock.restore()
-})
-
 describe('message commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>

package/src/platforms/instagram/commands/whoami.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+import { whoamiAction } from './whoami'
+
+let withInstagramClientSpy: ReturnType<typeof spyOn>
+let getProfileSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    getProfileSpy = spyOn(InstagramClient.prototype, 'getProfile').mockResolvedValue({
+      user_id: '987654321',
+      username: 'testuser',
+      full_name: 'Test User',
+      profile_pic_url: 'https://example.com/pic.jpg',
+    })
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(
+      async (_opts, fn) => {
+        const fakeClient = Object.create(InstagramClient.prototype) as InstagramClient
+        return fn(fakeClient)
+      },
+    )
+    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    getProfileSpy?.mockRestore()
+    withInstagramClientSpy?.mockRestore()
+    consoleLogSpy?.mockRestore()
+  })
+
+  test('outputs profile information', async () => {
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.user_id).toBe('987654321')
+    expect(output.username).toBe('testuser')
+    expect(output.full_name).toBe('Test User')
+    expect(output.profile_pic_url).toBe('https://example.com/pic.jpg')
+  })
+
+  test('outputs profile with null optional fields', async () => {
+    getProfileSpy.mockResolvedValue({
+      user_id: '987654321',
+      username: 'testuser',
+      full_name: null,
+      profile_pic_url: null,
+    })
+
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.full_name).toBeNull()
+    expect(output.profile_pic_url).toBeNull()
+  })
+})

package/src/platforms/instagram/commands/whoami.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { withInstagramClient } from './shared'
+
+export async function whoamiAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const profile = await withInstagramClient(options, (client) => client.getProfile())
+    console.log(formatOutput(profile, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--account <id>', 'Use a specific Instagram account')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/kakaotalk/cli.ts

@@ -4,7 +4,7 @@ import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand, profileCommand } from './commands/index'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands/index'
 import { ensureKakaoAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -31,7 +31,7 @@ program.hook('preAction', async (_thisCommand, actionCommand) => {
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
-program.addCommand(profileCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -5,6 +5,8 @@ import { KakaoTalkClient, KakaoTalkError } from './client'
 // Mock LocoSession at module level
 const mockLogin = mock(() => Promise.resolve({}))
 const mockGetChatList = mock(() => Promise.resolve({}))
+const mockGetChatLogs = mock(() => Promise.resolve({}))
+const mockGetChatInfo = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
@@ -14,6 +16,8 @@ mock.module('./protocol/session', () => ({
   LocoSession: class MockLocoSession {
     login = mockLogin
     getChatList = mockGetChatList
+    getChatLogs = mockGetChatLogs
+    getChatInfo = mockGetChatInfo
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
     close = mockClose
@@ -28,6 +32,8 @@ function makeLong(n: number): { low: number; high: number } {
 function resetAllMocks() {
   mockLogin.mockReset()
   mockGetChatList.mockReset()
+  mockGetChatLogs.mockReset()
+  mockGetChatInfo.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
   mockClose.mockReset()
@@ -67,6 +73,8 @@ describe('KakaoTalkClient', () => {
   beforeEach(() => {
     resetAllMocks()
     mockLogin.mockResolvedValue(DEFAULT_LOGIN_RESULT)
+    mockGetChatLogs.mockResolvedValue({ body: { status: 0, chatLogs: [], eof: true } })
+    mockGetChatInfo.mockResolvedValue({ body: { l: makeLong(99999) } })
   })
 
   afterEach(() => {
@@ -316,13 +324,14 @@ describe('KakaoTalkClient', () => {
 
   describe('getMessages', () => {
     test('returns formatted messages', async () => {
-      mockSyncMessages.mockResolvedValueOnce({
+      mockGetChatLogs.mockResolvedValueOnce({
         body: {
+          status: 0,
           chatLogs: [
-            { logId: makeLong(10), type: 1, authorId: 42, message: 'hello', sendAt: 1700000001 },
-            { logId: makeLong(11), type: 1, authorId: 43, message: 'world', sendAt: 1700000002 },
+            { logId: makeLong(10), chatId: 100, type: 1, authorId: 42, message: 'hello', sendAt: 1700000001 },
+            { logId: makeLong(11), chatId: 100, type: 1, authorId: 43, message: 'world', sendAt: 1700000002 },
           ],
-          isOK: true,
+          eof: true,
         },
       })
 
@@ -351,14 +360,15 @@ describe('KakaoTalkClient', () => {
     test('respects count option', async () => {
       const logs = Array.from({ length: 50 }, (_, i) => ({
         logId: makeLong(i + 1),
+        chatId: 100,
         type: 1,
         authorId: 1,
         message: `msg-${i}`,
         sendAt: 1700000000 + i,
       }))
 
-      mockSyncMessages.mockResolvedValueOnce({
-        body: { chatLogs: logs, isOK: true },
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: logs, eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -373,13 +383,14 @@ describe('KakaoTalkClient', () => {
     })
 
     test('sorts messages by sent_at ascending', async () => {
-      mockSyncMessages.mockResolvedValueOnce({
+      mockGetChatLogs.mockResolvedValueOnce({
         body: {
+          status: 0,
           chatLogs: [
-            { logId: makeLong(2), type: 1, authorId: 1, message: 'second', sendAt: 200 },
-            { logId: makeLong(1), type: 1, authorId: 1, message: 'first', sendAt: 100 },
+            { logId: makeLong(2), chatId: 100, type: 1, authorId: 1, message: 'second', sendAt: 200 },
+            { logId: makeLong(1), chatId: 100, type: 1, authorId: 1, message: 'first', sendAt: 100 },
           ],
-          isOK: true,
+          eof: true,
         },
       })
 
@@ -556,8 +567,8 @@ describe('KakaoTalkClient', () => {
     })
 
     test('reuses session across multiple calls', async () => {
-      mockSyncMessages.mockResolvedValue({
-        body: { chatLogs: [], isOK: true },
+      mockGetChatLogs.mockResolvedValue({
+        body: { status: 0, chatLogs: [], eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -574,8 +585,8 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockImplementation(
         () => new Promise((resolve) => setTimeout(() => resolve(DEFAULT_LOGIN_RESULT), 50)),
       )
-      mockSyncMessages.mockResolvedValue({
-        body: { chatLogs: [], isOK: true },
+      mockGetChatLogs.mockResolvedValue({
+        body: { status: 0, chatLogs: [], eof: true },
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })