agent-messenger 2.3.0 → 2.5.0

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

@@ -1,89 +1,73 @@
-import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
 import { addAction, removeAction } from './reaction'
 
-let clientAddReactionSpy: ReturnType<typeof spyOn>
-let clientRemoveReactionSpy: ReturnType<typeof spyOn>
-let credManagerLoadConfigSpy: ReturnType<typeof spyOn>
+let addReactionSpy: ReturnType<typeof spyOn>
+let removeReactionSpy: ReturnType<typeof spyOn>
+let getTokenWithExpirySpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  clientAddReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
-  clientRemoveReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
-  credManagerLoadConfigSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
-    current_account: 'work',
-    accounts: {
-      work: {
-        token: 'test-token',
-        account_type: 'work' as const,
-        current_team: null,
-        teams: {},
-      },
-    },
+  addReactionSpy = spyOn(TeamsClient.prototype, 'addReaction').mockResolvedValue(undefined)
+  removeReactionSpy = spyOn(TeamsClient.prototype, 'removeReaction').mockResolvedValue(undefined)
+  getTokenWithExpirySpy = spyOn(TeamsCredentialManager.prototype, 'getTokenWithExpiry').mockImplementation(() =>
+    Promise.resolve({ token: 'test-token', tokenExpiresAt: undefined }),
+  )
+
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => {
+    throw new Error(`process.exit(${_code})`)
   })
 })
 
 afterEach(() => {
-  clientAddReactionSpy?.mockRestore()
-  clientRemoveReactionSpy?.mockRestore()
-  credManagerLoadConfigSpy?.mockRestore()
+  addReactionSpy.mockRestore()
+  removeReactionSpy.mockRestore()
+  getTokenWithExpirySpy.mockRestore()
+  consoleLogSpy.mockRestore()
+  processExitSpy.mockRestore()
 })
 
 test('add: sends correct POST request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('remove: sends correct DELETE request with emoji', async () => {
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  console.log = consoleSpy
-
   try {
     await removeAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.success).toBe(true)
-    expect(output.team_id).toBe('team123')
-    expect(output.channel_id).toBe('ch123')
-    expect(output.message_id).toBe('msg123')
-    expect(output.emoji).toBe('like')
-  } finally {
-    console.log = originalLog
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.team_id).toBe('team123')
+  expect(output.channel_id).toBe('ch123')
+  expect(output.message_id).toBe('msg123')
+  expect(output.emoji).toBe('like')
 })
 
 test('add: handles missing token gracefully', async () => {
-  credManagerLoadConfigSpy?.mockResolvedValue(null)
-
-  const consoleSpy = mock((_msg: string) => {})
-  const originalLog = console.log
-  const originalExit = process.exit
-  process.exit = mock(() => {}) as any
-  console.log = consoleSpy
+  getTokenWithExpirySpy.mockImplementation(() => Promise.resolve(null))
 
   try {
     await addAction('team123', 'ch123', 'msg123', 'like', { pretty: false })
-    expect(consoleSpy).toHaveBeenCalled()
-    const output = JSON.parse(consoleSpy.mock.calls[0][0])
-    expect(output.error).toBeDefined()
-  } finally {
-    console.log = originalLog
-    process.exit = originalExit
-  }
+  } catch {}
+
+  expect(consoleLogSpy).toHaveBeenCalled()
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.error).toBeDefined()
+  expect(processExitSpy).toHaveBeenCalledWith(1)
 })

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

@@ -20,6 +20,7 @@ export async function addAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
@@ -56,6 +57,7 @@ export async function removeAction(
     if (!cred) {
       console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
+      return
     }
 
     const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })

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/chat.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListChats = mock(() =>
+  Promise.resolve([
+    { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+    { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+  ]),
+)
+
+const mockSearchChats = mock(() =>
+  Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+)
+
+const mockGetChat = mock(() =>
+  Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+)
+
+const mockClient = {
+  listChats: mockListChats,
+  searchChats: mockSearchChats,
+  getChat: mockGetChat,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { chatCommand } from './chat'
+
+describe('chat commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListChats.mockReset()
+    mockListChats.mockImplementation(() =>
+      Promise.resolve([
+        { id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 },
+        { id: 'chat-2', title: 'Random', type: 'group', unread_count: 5 },
+      ]),
+    )
+    mockSearchChats.mockReset()
+    mockSearchChats.mockImplementation(() =>
+      Promise.resolve([{ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }]),
+    )
+    mockGetChat.mockReset()
+    mockGetChat.mockImplementation(() =>
+      Promise.resolve({ id: 'chat-1', title: 'General', type: 'supergroup', unread_count: 0 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listChats with default limit', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(20)
+    })
+
+    test('calls listChats with custom limit', async () => {
+      await chatCommand.parseAsync(['list', '--limit', '5'], { from: 'user' })
+
+      expect(mockListChats).toHaveBeenCalledWith(5)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['list'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('search subcommand', () => {
+    test('calls searchChats with query and default limit', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 20)
+    })
+
+    test('calls searchChats with query and custom limit', async () => {
+      await chatCommand.parseAsync(['search', 'General', '--limit', '3'], { from: 'user' })
+
+      expect(mockSearchChats).toHaveBeenCalledWith('General', 3)
+    })
+
+    test('outputs JSON array to console', async () => {
+      await chatCommand.parseAsync(['search', 'General'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(1)
+    })
+  })
+
+  describe('get subcommand', () => {
+    test('calls getChat with chat reference', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(mockGetChat).toHaveBeenCalledWith('chat-1')
+    })
+
+    test('outputs JSON object to console', async () => {
+      await chatCommand.parseAsync(['get', 'chat-1'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe('chat-1')
+    })
+  })
+})

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/message.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:test'
+
+const mockListMessages = mock(() =>
+  Promise.resolve([
+    { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+    { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+  ]),
+)
+
+const mockSendMessage = mock(() =>
+  Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+)
+
+const mockClient = {
+  listMessages: mockListMessages,
+  sendMessage: mockSendMessage,
+}
+
+mock.module('./shared', () => ({
+  withTelegramClient: async (_opts: unknown, fn: (client: typeof mockClient) => Promise<unknown>) =>
+    fn(mockClient),
+}))
+
+import { messageCommand } from './message'
+
+describe('message commands', () => {
+  let consoleSpy: ReturnType<typeof spyOn>
+  let processExitSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    mockListMessages.mockReset()
+    mockListMessages.mockImplementation(() =>
+      Promise.resolve([
+        { id: 1, text: 'Hello', sender_id: 'user-1', date: 1000 },
+        { id: 2, text: 'World', sender_id: 'user-2', date: 2000 },
+      ]),
+    )
+    mockSendMessage.mockReset()
+    mockSendMessage.mockImplementation(() =>
+      Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
+    )
+    consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+    processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  describe('list subcommand', () => {
+    test('calls listMessages with chat reference and default limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 20)
+    })
+
+    test('calls listMessages with custom limit', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123', '--limit', '10'], { from: 'user' })
+
+      expect(mockListMessages).toHaveBeenCalledWith('chat-123', 10)
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['list', 'chat-123'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeArray()
+      expect(parsed).toHaveLength(2)
+    })
+  })
+
+  describe('send subcommand', () => {
+    test('calls sendMessage with chat reference and text', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'Hello there')
+    })
+
+    test('outputs JSON to console', async () => {
+      await messageCommand.parseAsync(['send', 'chat-123', 'Hello there'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed).toBeObject()
+      expect(parsed.id).toBe(3)
+    })
+  })
+})

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)