agent-messenger 1.0.0

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

@@ -0,0 +1,107 @@
+import { beforeEach, expect, mock, test } from 'bun:test'
+import { deleteAction, getAction, listAction, sendAction } from './message'
+
+mock.module('../client', () => ({
+  DiscordClient: mock(() => ({
+    sendMessage: mock(async () => ({
+      id: 'msg_123',
+      channel_id: 'ch_456',
+      author: { id: 'user_789', username: 'testuser' },
+      content: 'Hello world',
+      timestamp: '2025-01-29T10:00:00Z',
+    })),
+    getMessages: mock(async () => [
+      {
+        id: 'msg_123',
+        channel_id: 'ch_456',
+        author: { id: 'user_789', username: 'testuser' },
+        content: 'Hello world',
+        timestamp: '2025-01-29T10:00:00Z',
+      },
+      {
+        id: 'msg_124',
+        channel_id: 'ch_456',
+        author: { id: 'user_789', username: 'testuser' },
+        content: 'Second message',
+        timestamp: '2025-01-29T10:01:00Z',
+      },
+    ]),
+    getMessage: mock(async () => ({
+      id: 'msg_123',
+      channel_id: 'ch_456',
+      author: { id: 'user_789', username: 'testuser' },
+      content: 'Hello world',
+      timestamp: '2025-01-29T10:00:00Z',
+    })),
+    deleteMessage: mock(async () => undefined),
+  })),
+}))
+
+mock.module('../credential-manager', () => ({
+  DiscordCredentialManager: mock(() => ({
+    load: mock(async () => ({
+      token: 'test_token',
+      current_guild: 'guild_123',
+      guilds: {},
+    })),
+  })),
+}))
+
+mock.module('../../../shared/utils/output', () => ({
+  formatOutput: (data: any, pretty?: boolean) => JSON.stringify(data, null, pretty ? 2 : 0),
+}))
+
+mock.module('../../../shared/utils/error-handler', () => ({
+  handleError: (error: Error) => {
+    console.error(error.message)
+  },
+}))
+
+beforeEach(() => {
+  mock.restore()
+})
+
+test('send: returns message with id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('ch_456', 'Hello world', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('list: returns array of messages', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('ch_456', { limit: 50, pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+  expect(output).toContain('msg_124')
+})
+
+test('get: returns single message', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await getAction('ch_456', 'msg_123', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('msg_123')
+})
+
+test('delete: returns success', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('ch_456', 'msg_123', { force: true, pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('deleted')
+})

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

@@ -0,0 +1,182 @@
+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'
+import type { DiscordMessage } from '../types'
+
+export async function sendAction(
+  channelId: string,
+  content: string,
+  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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const message = await client.sendMessage(channelId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      author: message.author.username,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(
+  channelId: string,
+  options: { limit?: number; 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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const limit = options.limit || 50
+    const messages = await client.getMessages(channelId, limit)
+
+    const output = messages.map((msg: DiscordMessage) => ({
+      id: msg.id,
+      content: msg.content,
+      author: msg.author.username,
+      timestamp: msg.timestamp,
+      thread_id: msg.thread_id || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function getAction(
+  channelId: string,
+  messageId: string,
+  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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const message = await client.getMessage(channelId, messageId)
+
+    if (!message) {
+      console.log(formatOutput({ error: `Message not found: ${messageId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      author: message.author.username,
+      timestamp: message.timestamp,
+      thread_id: message.thread_id || null,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function deleteAction(
+  channelId: string,
+  messageId: string,
+  options: { force?: boolean; 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)
+      )
+      process.exit(1)
+    }
+
+    if (!options.force) {
+      console.log(
+        formatOutput({ warning: 'Use --force to confirm deletion', messageId }, options.pretty)
+      )
+      process.exit(0)
+    }
+
+    const client = new DiscordClient(config.token)
+    await client.deleteMessage(channelId, messageId)
+
+    console.log(formatOutput({ deleted: messageId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send message to channel')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<content>', 'Message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('List messages from channel')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--limit <n>', 'Number of messages to retrieve', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channelId: string, options: any) => {
+        listAction(channelId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single message by ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction)
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete message')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--force', 'Skip confirmation')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction)
+  )

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

@@ -0,0 +1,123 @@
+import { expect, mock, test } from 'bun:test'
+import { addAction, listAction, removeAction } from './reaction'
+
+// Mock modules
+mock.module('../client', () => ({
+  DiscordClient: mock(() => ({
+    addReaction: mock(async () => {}),
+    removeReaction: mock(async () => {}),
+    getMessage: mock(async () => ({
+      id: 'msg123',
+      channel_id: 'ch123',
+      author: { id: 'user123', username: 'testuser' },
+      content: 'test message',
+      timestamp: '2024-01-01T00:00:00Z',
+      reactions: [
+        {
+          emoji: { name: 'thumbsup', id: undefined },
+          count: 2,
+        },
+        {
+          emoji: { name: 'heart', id: undefined },
+          count: 1,
+        },
+      ],
+    })),
+  })),
+}))
+
+mock.module('../credential-manager', () => ({
+  DiscordCredentialManager: mock(() => ({
+    load: mock(async () => ({
+      token: 'test-token',
+    })),
+  })),
+}))
+
+test('add: sends correct PUT request with emoji', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  try {
+    await addAction('ch123', 'msg123', 'thumbsup', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.success).toBe(true)
+    expect(output.channel_id).toBe('ch123')
+    expect(output.message_id).toBe('msg123')
+    expect(output.emoji).toBe('thumbsup')
+  } finally {
+    console.log = originalLog
+  }
+})
+
+test('remove: sends correct DELETE request with emoji', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  try {
+    await removeAction('ch123', 'msg123', 'thumbsup', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.success).toBe(true)
+    expect(output.channel_id).toBe('ch123')
+    expect(output.message_id).toBe('msg123')
+    expect(output.emoji).toBe('thumbsup')
+  } finally {
+    console.log = originalLog
+  }
+})
+
+test('list: extracts reactions from message', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  console.log = consoleSpy
+
+  try {
+    await listAction('ch123', 'msg123', { pretty: false })
+    expect(consoleSpy).toHaveBeenCalled()
+    const output = JSON.parse(consoleSpy.mock.calls[0][0])
+    expect(output.channel_id).toBe('ch123')
+    expect(output.message_id).toBe('msg123')
+    expect(Array.isArray(output.reactions)).toBe(true)
+    expect(output.reactions.length).toBe(2)
+    expect(output.reactions[0].emoji.name).toBe('thumbsup')
+    expect(output.reactions[0].count).toBe(2)
+  } finally {
+    console.log = originalLog
+  }
+})
+
+test('add: handles missing token gracefully', async () => {
+  const credManagerMock = mock(() => ({
+    load: mock(async () => ({
+      token: null,
+    })),
+  }))
+
+  mock.module('../credential-manager', () => ({
+    DiscordCredentialManager: credManagerMock,
+  }))
+
+  const consoleSpy = mock((_msg: string) => {})
+  const originalLog = console.log
+  const originalExit = process.exit
+  let _exitCode = 0
+  process.exit = mock((code: number) => {
+    _exitCode = code
+  }) as any
+
+  console.log = consoleSpy
+
+  try {
+    await addAction('ch123', 'msg123', 'thumbsup', { 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
+  }
+})

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

@@ -0,0 +1,156 @@
+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 addAction(
+  channelId: string,
+  messageId: string,
+  emoji: string,
+  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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    await client.addReaction(channelId, messageId, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          channel_id: channelId,
+          message_id: messageId,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function removeAction(
+  channelId: string,
+  messageId: string,
+  emoji: string,
+  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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    await client.removeReaction(channelId, messageId, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          channel_id: channelId,
+          message_id: messageId,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(
+  channelId: string,
+  messageId: string,
+  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)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const message = await client.getMessage(channelId, messageId)
+
+    if (!message) {
+      console.log(
+        formatOutput(
+          {
+            error: 'Message not found',
+            channel_id: channelId,
+            message_id: messageId,
+          },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const reactions = (message as any).reactions || []
+
+    console.log(
+      formatOutput(
+        {
+          channel_id: channelId,
+          message_id: messageId,
+          reactions,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const reactionCommand = new Command('reaction')
+  .description('Reaction commands')
+  .addCommand(
+    new Command('add')
+      .description('Add emoji reaction to message')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<emoji>', 'Emoji name (without colons)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction)
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove emoji reaction from message')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<emoji>', 'Emoji name (without colons)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('List reactions on a message')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<message-id>', 'Message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )

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

@@ -0,0 +1,29 @@
+import { expect, test } from 'bun:test'
+import { snapshotCommand } from './snapshot'
+
+test('snapshot: command is defined', () => {
+  expect(snapshotCommand).toBeDefined()
+  expect(snapshotCommand.name()).toBe('snapshot')
+})
+
+test('snapshot: command has correct description', () => {
+  expect(snapshotCommand.description()).toContain('guild state')
+})
+
+test('snapshot: command has --channels-only option', () => {
+  const options = snapshotCommand.options
+  const channelsOnlyOption = options.find((opt) => opt.long === '--channels-only')
+  expect(channelsOnlyOption).toBeDefined()
+})
+
+test('snapshot: command has --users-only option', () => {
+  const options = snapshotCommand.options
+  const usersOnlyOption = options.find((opt) => opt.long === '--users-only')
+  expect(usersOnlyOption).toBeDefined()
+})
+
+test('snapshot: command has --limit option', () => {
+  const options = snapshotCommand.options
+  const limitOption = options.find((opt) => opt.long === '--limit')
+  expect(limitOption).toBeDefined()
+})

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

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+import { parallelMap } from '../../../shared/utils/concurrency'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import type { DiscordChannel } from '../types'
+
+export async function snapshotAction(options: {
+  channelsOnly?: boolean
+  usersOnly?: boolean
+  limit?: number
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token || !config.current_guild) {
+      console.log(
+        formatOutput({ error: 'No current guild set. Run "guild switch" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token as string)
+    const guildId = config.current_guild as string
+    const messageLimit = options.limit || 20
+
+    const snapshot: Record<string, any> = {}
+
+    const guild = await client.getGuild(guildId)
+    snapshot.guild = {
+      id: guild.id,
+      name: guild.name,
+    }
+
+    if (!options.usersOnly) {
+      const channels = await client.listChannels(guildId)
+
+      snapshot.channels = channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        type: ch.type,
+        topic: ch.topic,
+      }))
+
+      if (!options.channelsOnly) {
+        const isTextChannel = (ch: DiscordChannel) => ch.type === 0 || ch.type === 5
+        const textChannels = channels.filter(isTextChannel)
+
+        const channelMessages = await parallelMap(
+          textChannels,
+          async (channel: DiscordChannel) => {
+            const messages = await client.getMessages(channel.id, messageLimit)
+            return messages.map((msg) => ({
+              ...msg,
+              channel_name: channel.name,
+            }))
+          },
+          5
+        )
+
+        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+          channel_id: msg.channel_id,
+          channel_name: msg.channel_name,
+          id: msg.id,
+          author: msg.author.username,
+          content: msg.content,
+          timestamp: msg.timestamp,
+        }))
+      }
+    }
+
+    if (!options.channelsOnly) {
+      const users = await client.listUsers(guildId)
+
+      snapshot.members = users.map((u) => ({
+        id: u.id,
+        username: u.username,
+        global_name: u.global_name || null,
+      }))
+    }
+
+    console.log(formatOutput(snapshot, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const snapshotCommand = new Command()
+  .name('snapshot')
+  .description('Get comprehensive guild state for AI agents')
+  .option('--channels-only', 'Include only channels (exclude messages and members)')
+  .option('--users-only', 'Include only members (exclude channels and messages)')
+  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .action(async (options) => {
+    await snapshotAction({
+      channelsOnly: options.channelsOnly,
+      usersOnly: options.usersOnly,
+      limit: parseInt(options.limit, 10),
+      pretty: options.pretty,
+    })
+  })