agent-messenger 2.3.0 → 2.5.0

package/src/platforms/line/commands/friend.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { friendCommand } from './friend'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getFriendsSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getFriendsSpy = spyOn(LineClient.prototype, 'getFriends').mockResolvedValue([
+    {
+      mid: 'u111',
+      display_name: 'Alice',
+      picture_url: 'https://example.com/alice.jpg',
+      status_message: 'Hey!',
+    },
+    {
+      mid: 'u222',
+      display_name: 'Bob',
+      picture_url: 'https://example.com/bob.jpg',
+      status_message: 'Hello',
+    },
+  ])
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getFriendsSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs friends', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getFriendsSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].mid).toBe('u111')
+  expect(output[0].display_name).toBe('Alice')
+})
+
+test('list: outputs friends with metadata', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const friend = output[0]
+  expect(friend.mid).toBeDefined()
+  expect(friend.display_name).toBeDefined()
+})
+
+test('list: closes client after fetching friends', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs empty array when no friends', async () => {
+  // given
+  getFriendsSpy.mockResolvedValue([])
+
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(0)
+})
+
+test('list: includes all friend fields', async () => {
+  // when
+  await friendCommand.parseAsync(['node', 'friend', 'list'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output[0].picture_url).toBe('https://example.com/alice.jpg')
+  expect(output[0].status_message).toBe('Hey!')
+  expect(output[1].display_name).toBe('Bob')
+})

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

@@ -2,4 +2,4 @@ export { authCommand } from './auth'
 export { chatCommand } from './chat'
 export { friendCommand } from './friend'
 export { messageCommand } from './message'
-export { profileCommand } from './profile'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { messageCommand } from './message'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getMessagesSpy: ReturnType<typeof spyOn>
+let sendMessageSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getMessagesSpy = spyOn(LineClient.prototype, 'getMessages').mockResolvedValue([
+    {
+      message_id: 'msg-1',
+      chat_id: 'chat-1',
+      author_id: 'u123',
+      text: 'Hello world',
+      content_type: 'NONE',
+      sent_at: '2024-01-01T10:00:00Z',
+    },
+    {
+      message_id: 'msg-2',
+      chat_id: 'chat-1',
+      author_id: 'u456',
+      text: 'Hi there',
+      content_type: 'NONE',
+      sent_at: '2024-01-01T09:00:00Z',
+    },
+  ])
+
+  sendMessageSpy = spyOn(LineClient.prototype, 'sendMessage').mockResolvedValue({
+    success: true,
+    chat_id: 'chat-1',
+    message_id: 'msg-new',
+    sent_at: '2024-01-01T11:00:00Z',
+  })
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getMessagesSpy?.mockRestore()
+  sendMessageSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('list: fetches and outputs messages for a chat', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getMessagesSpy).toHaveBeenCalledWith('chat-1', { count: 20 })
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output).toHaveLength(2)
+  expect(output[0].message_id).toBe('msg-1')
+  expect(output[0].text).toBe('Hello world')
+})
+
+test('list: uses custom count when --count option provided', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1', '--count', '5'])
+
+  // then
+  expect(getMessagesSpy).toHaveBeenCalledWith('chat-1', { count: 5 })
+})
+
+test('list: closes client after fetching messages', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('send: sends message and outputs result', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'send', 'chat-1', 'Hello!'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(sendMessageSpy).toHaveBeenCalledWith('chat-1', 'Hello!')
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.success).toBe(true)
+  expect(output.message_id).toBe('msg-new')
+})
+
+test('send: closes client after sending message', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'send', 'chat-1', 'Hello!'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('list: outputs messages with metadata', async () => {
+  // when
+  await messageCommand.parseAsync(['node', 'message', 'list', 'chat-1'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  const msg = output[0]
+  expect(msg.message_id).toBeDefined()
+  expect(msg.chat_id).toBeDefined()
+  expect(msg.author_id).toBeDefined()
+  expect(msg.sent_at).toBeDefined()
+})

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

@@ -0,0 +1,85 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+import { LineClient } from '../client'
+import { whoamiCommand } from './whoami'
+
+let loginSpy: ReturnType<typeof spyOn>
+let getProfileSpy: ReturnType<typeof spyOn>
+let closeSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof mock>
+
+beforeEach(() => {
+  loginSpy = spyOn(LineClient.prototype, 'login').mockImplementation(async function (this: LineClient) {
+    return this
+  })
+
+  getProfileSpy = spyOn(LineClient.prototype, 'getProfile').mockResolvedValue({
+    mid: 'u1234567890abcdef',
+    display_name: 'Test User',
+    picture_url: 'https://example.com/pic.jpg',
+    status_message: 'Hello LINE!',
+  })
+
+  closeSpy = spyOn(LineClient.prototype, 'close').mockImplementation(() => {})
+  consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+})
+
+afterEach(() => {
+  loginSpy?.mockRestore()
+  getProfileSpy?.mockRestore()
+  closeSpy?.mockRestore()
+  console.log = originalConsoleLog
+})
+
+test('whoami: fetches and outputs profile', async () => {
+  // when
+  await whoamiCommand.parseAsync(['node', 'whoami'])
+
+  // then
+  expect(loginSpy).toHaveBeenCalledTimes(1)
+  expect(getProfileSpy).toHaveBeenCalledTimes(1)
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.mid).toBe('u1234567890abcdef')
+  expect(output.display_name).toBe('Test User')
+})
+
+test('whoami: outputs profile with all fields', async () => {
+  // when
+  await whoamiCommand.parseAsync(['node', 'whoami'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.mid).toBeDefined()
+  expect(output.display_name).toBeDefined()
+  expect(output.picture_url).toBeDefined()
+  expect(output.status_message).toBeDefined()
+})
+
+test('whoami: closes client after fetching profile', async () => {
+  // when
+  await whoamiCommand.parseAsync(['node', 'whoami'])
+
+  // then
+  expect(closeSpy).toHaveBeenCalledTimes(1)
+})
+
+test('whoami: outputs profile with picture_url', async () => {
+  // when
+  await whoamiCommand.parseAsync(['node', 'whoami'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.picture_url).toBe('https://example.com/pic.jpg')
+})
+
+test('whoami: outputs profile with status_message', async () => {
+  // when
+  await whoamiCommand.parseAsync(['node', 'whoami'])
+
+  // then
+  const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+  expect(output.status_message).toBe('Hello LINE!')
+})

package/src/platforms/line/commands/{profile.ts → whoami.ts}

@@ -5,7 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { LineClient } from '../client'
 
-async function profileAction(options: { pretty?: boolean }): Promise<void> {
+async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
   let client: LineClient | undefined
   try {
     client = await new LineClient().login()
@@ -18,7 +18,7 @@ async function profileAction(options: { pretty?: boolean }): Promise<void> {
   }
 }
 
-export const profileCommand = new Command('profile')
-  .description('Show your LINE profile')
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
   .option('--pretty', 'Pretty print JSON output')
-  .action(profileAction)
+  .action(whoamiAction)

package/src/platforms/slack/cli.ts

@@ -22,6 +22,7 @@ import {
   unreadCommand,
   userCommand,
   usergroupCommand,
+  whoamiCommand,
   workspaceCommand,
 } from './commands/index'
 import { ensureSlackAuth } from './ensure-auth'
@@ -66,6 +67,7 @@ program.addCommand(bookmarkCommand)
 program.addCommand(reminderCommand)
 program.addCommand(emojiCommand)
 program.addCommand(usergroupCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -15,4 +15,5 @@ export { snapshotCommand } from './snapshot'
 export { unreadCommand } from './unread'
 export { userCommand } from './user'
 export { usergroupCommand } from './usergroup'
+export { whoamiCommand } from './whoami'
 export { workspaceCommand } from './workspace'

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

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import { CredentialManager } from '@/platforms/slack/credential-manager'
+import { whoamiAction, whoamiCommand } from '@/platforms/slack/commands/whoami'
+
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let clientGetUserSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+const mockWorkspace = {
+  workspace_id: 'T123',
+  workspace_name: 'Test Workspace',
+  token: 'xoxc-test',
+  cookie: 'test-cookie',
+}
+
+const mockAuthInfo = {
+  user_id: 'U123',
+  team_id: 'T123',
+  user: 'alice',
+  team: 'Test Workspace',
+}
+
+const mockUser = {
+  id: 'U123',
+  name: 'alice',
+  real_name: 'Alice Smith',
+  is_admin: true,
+  is_owner: false,
+  is_bot: false,
+  is_app_user: false,
+  profile: {
+    email: 'alice@example.com',
+    title: 'Engineer',
+  },
+}
+
+beforeEach(() => {
+  credManagerSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue(mockWorkspace)
+  clientTestAuthSpy = spyOn(SlackClient.prototype, 'testAuth').mockResolvedValue(mockAuthInfo)
+  clientGetUserSpy = spyOn(SlackClient.prototype, 'getUser').mockResolvedValue(mockUser)
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  credManagerSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  clientGetUserSpy?.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 fields', async () => {
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'U123',
+      name: 'alice',
+      real_name: 'Alice Smith',
+      is_admin: true,
+      is_owner: false,
+      is_bot: false,
+      is_app_user: false,
+      team_id: 'T123',
+      team: 'Test Workspace',
+      profile: {
+        email: 'alice@example.com',
+        title: 'Engineer',
+      },
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+  await whoamiAction({ pretty: true })
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'U123',
+        name: 'alice',
+        real_name: 'Alice Smith',
+        is_admin: true,
+        is_owner: false,
+        is_bot: false,
+        is_app_user: false,
+        team_id: 'T123',
+        team: 'Test Workspace',
+        profile: {
+          email: 'alice@example.com',
+          title: 'Engineer',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with error when no workspace is set', async () => {
+  credManagerSpy.mockResolvedValue(null)
+
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({ error: 'No current workspace set. Run "auth extract" first.' }),
+  )
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

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

@@ -0,0 +1,139 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockResolveChannel = mock((_channel: string) => Promise.resolve('C123456'))
+const mockListChannels = mock(() =>
+  Promise.resolve([
+    {
+      id: 'C123456',
+      name: 'general',
+      is_private: false,
+      is_archived: false,
+      created: 1609459200,
+      creator: 'U123',
+    },
+    {
+      id: 'C789012',
+      name: 'random',
+      is_private: false,
+      is_archived: false,
+      created: 1609459200,
+      creator: 'U123',
+    },
+  ]),
+)
+const mockGetChannelInfo = mock(() =>
+  Promise.resolve({
+    id: 'C123456',
+    name: 'general',
+    is_private: false,
+    is_archived: false,
+    created: 1609459200,
+    creator: 'U123',
+    topic: { value: 'General discussion', creator: 'U123', last_set: 1609459200 },
+    purpose: { value: 'Company-wide announcements', creator: 'U123', last_set: 1609459200 },
+  }),
+)
+
+mock.module('../client', () => ({
+  SlackBotClient: class MockSlackBotClient {
+    async login(_credentials?: { token: string }) {
+      return this
+    }
+    resolveChannel = mockResolveChannel
+    listChannels = mockListChannels
+    getChannelInfo = mockGetChannelInfo
+  },
+}))
+
+import { SlackBotClient } from '../client'
+
+describe('channel commands', () => {
+  beforeEach(() => {
+    mockResolveChannel.mockClear()
+    mockListChannels.mockClear()
+    mockGetChannelInfo.mockClear()
+  })
+
+  describe('listChannels', () => {
+    test('returns list of channels', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channels = await client.listChannels()
+
+      // then
+      expect(channels).toHaveLength(2)
+      expect(channels[0].name).toBe('general')
+      expect(channels[1].name).toBe('random')
+    })
+
+    test('includes channel metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channels = await client.listChannels()
+      const channel = channels[0]
+
+      // then
+      expect(channel.id).toBeDefined()
+      expect(channel.name).toBeDefined()
+      expect(channel.is_private).toBe(false)
+      expect(channel.is_archived).toBe(false)
+      expect(channel.created).toBeDefined()
+    })
+
+    test('passes limit option', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listChannels({ limit: 50 })
+
+      // then
+      expect(mockListChannels).toHaveBeenCalledWith({ limit: 50 })
+    })
+  })
+
+  describe('getChannelInfo', () => {
+    test('returns channel details', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channel = await client.getChannelInfo('C123456')
+
+      // then
+      expect(channel.id).toBe('C123456')
+      expect(channel.name).toBe('general')
+      expect(channel.is_private).toBe(false)
+    })
+
+    test('includes topic and purpose', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channel = await client.getChannelInfo('C123456')
+
+      // then
+      expect(channel.topic?.value).toBe('General discussion')
+      expect(channel.purpose?.value).toBe('Company-wide announcements')
+    })
+  })
+
+  describe('resolveChannel', () => {
+    test('resolves channel name to ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const channelId = await client.resolveChannel('general')
+
+      // then
+      expect(channelId).toBe('C123456')
+      expect(mockResolveChannel).toHaveBeenCalledWith('general')
+    })
+  })
+})

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'