agent-messenger 2.3.0 → 2.5.0

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

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockGetAccount = mock(() =>
+  Promise.resolve({
+    id: 'account-1',
+    name: 'Test User',
+    email: 'test@example.com',
+    emailVerified: true,
+    language: 'en',
+    country: 'US',
+    createdAt: 1700000000000,
+  }),
+)
+
+mock.module('./shared', () => ({
+  getClient: async () => ({
+    getAccount: mockGetAccount,
+  }),
+  getCurrentWorkspaceId: async () => 'ws-1',
+}))
+
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    mockGetAccount.mockReset()
+    mockGetAccount.mockImplementation(() =>
+      Promise.resolve({
+        id: 'account-1',
+        name: 'Test User',
+        email: 'test@example.com',
+        emailVerified: true,
+        language: 'en',
+        country: 'US',
+        createdAt: 1700000000000,
+      }),
+    )
+  })
+
+  test('whoamiAction returns account info', async () => {
+    const result = await whoamiAction({})
+
+    expect(mockGetAccount).toHaveBeenCalled()
+    expect(result.account).toEqual({
+      id: 'account-1',
+      name: 'Test User',
+      email: 'test@example.com',
+      email_verified: true,
+      language: 'en',
+      country: 'US',
+      created_at: 1700000000000,
+    })
+    expect(result.error).toBeUndefined()
+  })
+
+  test('whoamiAction returns error when getAccount fails', async () => {
+    mockGetAccount.mockImplementation(() => Promise.reject(new Error('Not authenticated')))
+
+    const result = await whoamiAction({})
+
+    expect(result.error).toBe('Not authenticated')
+    expect(result.account).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,62 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { getClient } from './shared'
+
+interface ActionOptions {
+  workspace?: string
+  pretty?: boolean
+}
+
+interface WhoamiResult {
+  account?: {
+    id: string
+    name: string
+    email: string
+    email_verified: boolean
+    language: string
+    country: string
+    created_at: number
+  }
+  error?: string
+}
+
+export async function whoamiAction(options: ActionOptions = {}): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const account = await client.getAccount()
+    return {
+      account: {
+        id: account.id,
+        name: account.name,
+        email: account.email,
+        email_verified: account.emailVerified,
+        language: account.language,
+        country: account.country,
+        created_at: account.createdAt,
+      },
+    }
+  } 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 function createWhoamiCommand(): Command {
+  return new Command('whoami')
+    .description('Show current authenticated user')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--pretty', 'Pretty print JSON output')
+    .action(async (opts: ActionOptions) => {
+      cliOutput(await whoamiAction(opts), opts.pretty)
+    })
+}
+
+export const whoamiCommand = createWhoamiCommand()

package/src/platforms/channeltalkbot/cli.ts

@@ -11,6 +11,7 @@ import {
   managerCommand,
   messageCommand,
   snapshotCommand,
+  whoamiCommand,
 } from './commands/index'
 
 const program = new Command()
@@ -24,6 +25,7 @@ program
   .option('--bot <name>', 'Bot name to use for sending messages')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(messageCommand)
 program.addCommand(chatCommand)
 program.addCommand(groupCommand)

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

@@ -5,3 +5,4 @@ export { groupCommand } from './group'
 export { managerCommand } from './manager'
 export { messageCommand } from './message'
 export { snapshotCommand } from './snapshot'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,104 @@
+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 mockGetChannel = mock(() =>
+  Promise.resolve({
+    id: 'channel-id-123',
+    name: 'Test Channel',
+    homepageUrl: 'https://test.channel.io',
+    description: 'Test channel description',
+  }),
+)
+
+mock.module('../client', () => ({
+  ChannelBotClient: class MockChannelBotClient {
+    async login(_credentials?: { accessKey: string; accessSecret: string }) {
+      return this
+    }
+    getChannel = mockGetChannel
+  },
+}))
+
+import { ChannelBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `channeltalkbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_CHANNELBOT_ACCESS_KEY
+    delete process.env.E2E_CHANNELBOT_ACCESS_SECRET
+    mockGetChannel.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns channel info for current workspace', async () => {
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Test Workspace',
+      access_key: 'key123',
+      access_secret: 'secret123',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.id).toBe('channel-id-123')
+    expect(result.name).toBe('Test Channel')
+    expect(result.homepage_url).toBe('https://test.channel.io')
+    expect(result.description).toBe('Test channel description')
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns channel info for specific --workspace', async () => {
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Workspace 1',
+      access_key: 'key1',
+      access_secret: 'secret1',
+    })
+    await manager.setCredentials({
+      workspace_id: 'workspace2',
+      workspace_name: 'Workspace 2',
+      access_key: 'key2',
+      access_secret: 'secret2',
+    })
+
+    const result = await whoamiAction({ workspace: 'workspace1', _credManager: manager })
+
+    expect(result.id).toBe('channel-id-123')
+    expect(result.name).toBe('Test Channel')
+    expect(mockGetChannel).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockGetChannel.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Test Workspace',
+      access_key: 'key123',
+      access_secret: 'secret123',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})

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/discord/credential-manager.test.ts

@@ -1,10 +1,11 @@
-import { afterAll, describe, expect, test } from 'bun:test'
+import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { existsSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { DiscordCredentialManager } from './credential-manager'
 
 const testDirs: string[] = []
+let savedEnv: { token?: string; serverId?: string }
 
 function setup(): DiscordCredentialManager {
   const testConfigDir = join(
@@ -15,6 +16,22 @@ function setup(): DiscordCredentialManager {
   return new DiscordCredentialManager(testConfigDir)
 }
 
+beforeEach(() => {
+  savedEnv = {
+    token: process.env.E2E_DISCORD_TOKEN,
+    serverId: process.env.E2E_DISCORD_SERVER_ID,
+  }
+  delete process.env.E2E_DISCORD_TOKEN
+  delete process.env.E2E_DISCORD_SERVER_ID
+})
+
+afterEach(() => {
+  if (savedEnv.token !== undefined) process.env.E2E_DISCORD_TOKEN = savedEnv.token
+  else delete process.env.E2E_DISCORD_TOKEN
+  if (savedEnv.serverId !== undefined) process.env.E2E_DISCORD_SERVER_ID = savedEnv.serverId
+  else delete process.env.E2E_DISCORD_SERVER_ID
+})
+
 afterAll(() => {
   for (const dir of testDirs) {
     rmSync(dir, { recursive: true, force: true })

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/client.ts

@@ -49,7 +49,7 @@ export class DiscordBotClient {
   private getHeaders(): Record<string, string> {
     return {
       Authorization: `Bot ${this.ensureAuth()}`,
-      'User-Agent': 'DiscordBot (https://github.com/devxoul/agent-messenger, 1.0)',
+      'User-Agent': 'DiscordBot (https://github.com/agent-messenger/agent-messenger, 1.0)',
       'Content-Type': 'application/json',
     }
   }
@@ -186,7 +186,7 @@ export class DiscordBotClient {
 
       const headers: Record<string, string> = {
         Authorization: `Bot ${this.ensureAuth()}`,
-        'User-Agent': 'DiscordBot (https://github.com/devxoul/agent-messenger, 1.0)',
+        'User-Agent': 'DiscordBot (https://github.com/agent-messenger/agent-messenger, 1.0)',
       }
 
       let response: Response

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)