agent-messenger 2.4.0 → 2.5.0

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

@@ -0,0 +1,40 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+export async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+    if (!workspace) {
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      return process.exit(1)
+    }
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const authInfo = await client.testAuth()
+    const user = await client.getUser(authInfo.user_id)
+
+    const output = {
+      id: user.id,
+      name: user.name,
+      real_name: user.real_name,
+      is_admin: user.is_admin,
+      is_owner: user.is_owner,
+      is_bot: user.is_bot,
+      is_app_user: user.is_app_user,
+      team_id: authInfo.team_id,
+      team: authInfo.team,
+      profile: user.profile,
+    }
+    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/slackbot/cli.ts

@@ -3,7 +3,7 @@
 import { Command } from 'commander'
 
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, channelCommand, messageCommand, reactionCommand, userCommand } from './commands/index'
+import { authCommand, channelCommand, messageCommand, reactionCommand, userCommand, whoamiCommand } from './commands/index'
 
 const program = new Command()
 
@@ -14,6 +14,7 @@ program
   .option('--bot <id>', 'Use specific bot (default: current)')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(messageCommand)
 program.addCommand(channelCommand)
 program.addCommand(userCommand)

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

@@ -3,3 +3,4 @@ export { channelCommand } from './channel'
 export { messageCommand } from './message'
 export { reactionCommand } from './reaction'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,102 @@
+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({
+    user_id: 'U123',
+    team_id: 'T456',
+    bot_id: 'B789',
+    user: 'testbot',
+    team: 'Test Team',
+  }),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: any) {
+      return this
+    }
+    testAuth = mockTestAuth
+  },
+}))
+
+import { SlackBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `slackbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_SLACKBOT_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 SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'B789',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.user_id).toBe('U123')
+    expect(result.team_id).toBe('T456')
+    expect(result.bot_id).toBe('B789')
+    expect(result.user).toBe('testbot')
+    expect(result.team).toBe('Test Team')
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns auth info for specific --bot', async () => {
+    const manager = new SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    })
+
+    const result = await whoamiAction({ bot: 'deploy', _credManager: manager })
+
+    expect(result.user_id).toBe('U123')
+    expect(result.team_id).toBe('T456')
+    expect(mockTestAuth).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new SlackBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'xoxb-test-token',
+      workspace_id: 'T456',
+      workspace_name: 'Test Workspace',
+      bot_id: 'B789',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})

package/src/platforms/slackbot/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 {
+  user_id?: string
+  team_id?: string
+  bot_id?: string
+  user?: string
+  team?: string
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.testAuth()
+    return {
+      user_id: info.user_id,
+      team_id: info.team_id,
+      bot_id: info.bot_id,
+      user: info.user,
+      team: info.team,
+    }
+  } 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/teams/cli.ts

@@ -13,6 +13,7 @@ import {
   snapshotCommand,
   teamCommand,
   userCommand,
+  whoamiCommand,
 } from './commands'
 import { TeamsCredentialManager } from './credential-manager'
 import { ensureTeamsAuth } from './ensure-auth'
@@ -53,6 +54,7 @@ program.addCommand(messageCommand)
 program.addCommand(reactionCommand)
 program.addCommand(snapshotCommand)
 program.addCommand(userCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -10,3 +10,4 @@ export { reactionCommand } from './reaction'
 export { snapshotAction, snapshotCommand } from './snapshot'
 export { teamCommand } from './team'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,83 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import { TeamsClient } from '@/platforms/teams/client'
+import { TeamsCredentialManager } from '@/platforms/teams/credential-manager'
+import { whoamiAction, whoamiCommand } from '@/platforms/teams/commands/whoami'
+
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+const mockCred = {
+  token: 'test-teams-token',
+  tokenExpiresAt: '2099-01-01T00:00:00.000Z',
+}
+
+const mockUser = {
+  id: 'ME',
+  displayName: 'Test User',
+}
+
+beforeEach(() => {
+  credManagerSpy = spyOn(TeamsCredentialManager.prototype, 'getTokenWithExpiry').mockResolvedValue(mockCred)
+  clientTestAuthSpy = spyOn(TeamsClient.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 id and displayName', async () => {
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'ME',
+      displayName: 'Test User',
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+  await whoamiAction({ pretty: true })
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'ME',
+        displayName: 'Test User',
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with error when not authenticated', async () => {
+  credManagerSpy.mockResolvedValue(null)
+
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({ error: 'Not authenticated. Run "auth extract" first.' }),
+  )
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

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

@@ -0,0 +1,33 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+export async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      return process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      displayName: user.displayName,
+    }
+    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/telegram/cli.ts

@@ -2,7 +2,7 @@
 
 import { Command } from 'commander'
 import pkg from '../../../package.json' with { type: 'json' }
-import { authCommand, chatCommand, messageCommand } from './commands'
+import { authCommand, chatCommand, messageCommand, whoamiCommand } from './commands'
 
 const program = new Command()
 
@@ -14,6 +14,7 @@ program
 program.addCommand(authCommand)
 program.addCommand(chatCommand)
 program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
 
 await program.parseAsync(process.argv)
 

package/src/platforms/telegram/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/telegram/commands/whoami.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { TelegramTdlibClient } from '../client'
+import type { TelegramAccount } from '../types'
+import { TelegramCredentialManager } from '../credential-manager'
+import * as sharedModule from './shared'
+import { whoamiAction } from './whoami'
+
+const mockAuthStatus = {
+  account_id: 'plus-12025551234',
+  phone_number: '+12025551234',
+  authorization_state: 'authorizationStateReady',
+  authenticated: true,
+  user: {
+    id: 123456,
+    first_name: 'Test',
+    last_name: 'User',
+    username: 'testuser',
+    phone_number: '12025551234',
+    type: 'user' as const,
+  },
+}
+
+let withTelegramClientSpy: ReturnType<typeof spyOn>
+let getAuthStatusSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    getAuthStatusSpy = spyOn(TelegramTdlibClient.prototype, 'getAuthStatus').mockResolvedValue(mockAuthStatus)
+    withTelegramClientSpy = spyOn(sharedModule, 'withTelegramClient').mockImplementation(
+      async (_opts, fn) => {
+        const fakeClient = Object.create(TelegramTdlibClient.prototype) as TelegramTdlibClient
+        return fn(fakeClient, {} as TelegramAccount, new TelegramCredentialManager())
+      },
+    )
+    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    getAuthStatusSpy?.mockRestore()
+    withTelegramClientSpy?.mockRestore()
+    consoleLogSpy?.mockRestore()
+  })
+
+  test('outputs account info with user when authenticated', async () => {
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.account_id).toBe('plus-12025551234')
+    expect(output.phone_number).toBe('+12025551234')
+    expect(output.authenticated).toBe(true)
+    expect(output.user).toBeDefined()
+    expect(output.user.id).toBe(123456)
+    expect(output.user.username).toBe('testuser')
+  })
+
+  test('omits user field when not present', async () => {
+    getAuthStatusSpy.mockResolvedValue({
+      account_id: 'plus-12025551234',
+      phone_number: '+12025551234',
+      authorization_state: 'authorizationStateWaitCode',
+      authenticated: false,
+    })
+
+    await whoamiAction({})
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+    expect(output.account_id).toBe('plus-12025551234')
+    expect(output.authenticated).toBe(false)
+    expect(output.user).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,29 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { withTelegramClient } from './shared'
+
+export async function whoamiAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    await withTelegramClient(options, async (client) => {
+      const status = await client.getAuthStatus()
+      const output = {
+        account_id: status.account_id,
+        phone_number: status.phone_number,
+        authenticated: status.authenticated,
+        ...status.user && { user: status.user },
+      }
+      console.log(formatOutput(output, 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 Telegram account')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/webex/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, memberCommand, messageCommand, snapshotCommand, spaceCommand } from './commands'
+import { authCommand, memberCommand, messageCommand, snapshotCommand, spaceCommand, whoamiCommand } from './commands'
 import { ensureWebexAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -33,6 +33,7 @@ program.addCommand(memberCommand)
 program.addCommand(messageCommand)
 program.addCommand(snapshotCommand)
 program.addCommand(spaceCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)