agent-messenger 1.0.0

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

@@ -0,0 +1,127 @@
+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 listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token || !config.current_guild) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const channels = await client.listChannels(config.current_guild)
+
+    const textChannels = channels.filter((ch) => ch.type === 0)
+
+    const output = textChannels.map((ch) => ({
+      id: ch.id,
+      name: ch.name,
+      type: ch.type,
+      parent_id: (ch as any).parent_id || null,
+      topic: ch.topic || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(channelId: 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 channel = await client.getChannel(channelId)
+
+    const output = {
+      id: channel.id,
+      name: channel.name,
+      type: channel.type,
+      guild_id: channel.guild_id,
+      topic: channel.topic || null,
+      parent_id: (channel as any).parent_id || null,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function historyAction(
+  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 messages = await client.getMessages(channelId, options.limit || 50)
+
+    const output = messages.map((msg) => ({
+      id: msg.id,
+      author: msg.author.username,
+      content: msg.content,
+      timestamp: msg.timestamp,
+      thread_id: msg.thread_id || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const channelCommand = new Command('channel')
+  .description('Channel commands')
+  .addCommand(
+    new Command('list')
+      .description('List channels in current guild')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get channel info')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('history')
+      .description('Get channel message history')
+      .argument('<channel-id>', 'Channel ID')
+      .option('--limit <n>', 'Number of messages to fetch', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channelId, options) => {
+        historyAction(channelId, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )

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

@@ -0,0 +1,98 @@
+import { beforeEach, expect, mock, test } from 'bun:test'
+import { infoAction, listAction, uploadAction } from './file'
+
+mock.module('../client', () => ({
+  DiscordClient: mock(() => ({
+    uploadFile: mock(async () => ({
+      id: 'file_123',
+      filename: 'test.pdf',
+      size: 1024,
+      url: 'https://cdn.discordapp.com/attachments/123/456/test.pdf',
+      content_type: 'application/pdf',
+    })),
+    listFiles: mock(async () => [
+      {
+        id: 'file_123',
+        filename: 'test.pdf',
+        size: 1024,
+        url: 'https://cdn.discordapp.com/attachments/123/456/test.pdf',
+        content_type: 'application/pdf',
+      },
+      {
+        id: 'file_124',
+        filename: 'image.png',
+        size: 2048,
+        url: 'https://cdn.discordapp.com/attachments/123/457/image.png',
+        content_type: 'image/png',
+      },
+    ]),
+  })),
+}))
+
+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)
+  },
+}))
+
+mock.module('node:fs', () => ({
+  readFileSync: () => Buffer.from('test file content'),
+}))
+
+mock.module('node:path', () => ({
+  resolve: (path: string) => path,
+}))
+
+beforeEach(() => {
+  mock.restore()
+})
+
+test('upload: sends multipart request and returns file info', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await uploadAction('ch_456', '/path/to/test.pdf', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('test.pdf')
+})
+
+test('list: filters messages with attachments', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('ch_456', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('file_124')
+})
+
+test('info: returns single file details', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await infoAction('ch_456', 'file_123', { pretty: false })
+
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('file_123')
+  expect(output).toContain('test.pdf')
+})

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

@@ -0,0 +1,134 @@
+import { resolve } from 'node:path'
+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 { DiscordFile } from '../types'
+
+export async function uploadAction(
+  channelId: string,
+  path: string,
+  options: { filename?: string; 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 filePath = resolve(path)
+    const file = await client.uploadFile(channelId, filePath)
+
+    const output = {
+      id: file.id,
+      filename: file.filename,
+      size: file.size,
+      url: file.url,
+      content_type: file.content_type || null,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function listAction(channelId: 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 files = await client.listFiles(channelId)
+
+    const output = files.map((file: DiscordFile) => ({
+      id: file.id,
+      filename: file.filename,
+      size: file.size,
+      url: file.url,
+      content_type: file.content_type || null,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(
+  channelId: string,
+  fileId: 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 files = await client.listFiles(channelId)
+    const fileData = files.find((f) => f.id === fileId)
+
+    if (!fileData) {
+      console.log(formatOutput({ error: `File not found: ${fileId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      id: fileData.id,
+      filename: fileData.filename,
+      size: fileData.size,
+      url: fileData.url,
+      content_type: fileData.content_type || null,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const fileCommand = new Command('file')
+  .description('file commands')
+  .addCommand(
+    new Command('upload')
+      .description('upload file to channel')
+      .argument('<channel>', 'channel ID')
+      .argument('<path>', 'file path')
+      .option('--filename <name>', 'override filename')
+      .action(uploadAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('list files in channel')
+      .argument('<channel>', 'channel ID')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('show file details')
+      .argument('<channel>', 'channel ID')
+      .argument('<file>', 'file ID')
+      .action(infoAction)
+  )

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

@@ -0,0 +1,117 @@
+import { expect, mock, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+// Mock modules
+mock.module('../client', () => ({
+  DiscordClient: mock((_token: string) => ({
+    listGuilds: mock(async () => [
+      { id: 'guild-1', name: 'Guild One', icon: 'icon1', owner: true },
+      { id: 'guild-2', name: 'Guild Two', icon: 'icon2', owner: false },
+    ]),
+    getGuild: mock(async (guildId: string) => {
+      if (guildId === 'guild-1') {
+        return { id: 'guild-1', name: 'Guild One', icon: 'icon1', owner: true }
+      }
+      if (guildId === 'guild-2') {
+        return { id: 'guild-2', name: 'Guild Two', icon: 'icon2', owner: false }
+      }
+      throw new Error('Guild not found')
+    }),
+  })),
+}))
+
+mock.module('../credential-manager', () => ({
+  DiscordCredentialManager: mock(() => ({
+    load: mock(async () => ({
+      token: 'test-token',
+      current_guild: 'guild-1',
+      guilds: {
+        'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
+        'guild-2': { guild_id: 'guild-2', guild_name: 'Guild Two' },
+      },
+    })),
+    setCurrentGuild: mock(async () => {}),
+    getCurrentGuild: mock(async () => 'guild-1'),
+  })),
+}))
+
+test('list: returns guilds with current marker', async () => {
+  // given: credential manager with guilds
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+
+  // when: list action is called
+  expect(config.guilds).toBeDefined()
+  expect(Object.keys(config.guilds)).toHaveLength(2)
+
+  // then: guilds are returned
+  expect(config.guilds['guild-1']).toBeDefined()
+  expect(config.guilds['guild-2']).toBeDefined()
+})
+
+test('list: marks current guild', async () => {
+  // given: credential manager with current guild set
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+  const current = await credManager.getCurrentGuild()
+
+  // when: checking current guild
+  expect(current).toBe('guild-1')
+
+  // then: current guild is marked
+  expect(config.current_guild).toBe('guild-1')
+})
+
+test('info: returns guild details', async () => {
+  // given: discord client with guild data
+  const client = new DiscordClient('test-token')
+  const guild = await client.getGuild('guild-1')
+
+  // when: getting guild info
+  expect(guild).toBeDefined()
+
+  // then: guild details are returned
+  expect(guild.id).toBe('guild-1')
+  expect(guild.name).toBe('Guild One')
+  expect(guild.icon).toBe('icon1')
+  expect(guild.owner).toBe(true)
+})
+
+test('info: throws error for non-existent guild', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: getting non-existent guild
+  // then: error is thrown
+  try {
+    await client.getGuild('non-existent')
+    expect(true).toBe(false) // should not reach here
+  } catch (error) {
+    expect((error as Error).message).toContain('Guild not found')
+  }
+})
+
+test('switch: updates current guild', async () => {
+  // given: credential manager
+  const credManager = new DiscordCredentialManager()
+
+  // when: switching guild
+  await credManager.setCurrentGuild('guild-2')
+
+  // then: setCurrentGuild is called
+  expect(credManager.setCurrentGuild).toHaveBeenCalledWith('guild-2')
+})
+
+test('current: returns current guild info', async () => {
+  // given: credential manager with current guild
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+
+  // when: getting current guild
+  const current = await credManager.getCurrentGuild()
+
+  // then: current guild is returned
+  expect(current).toBe('guild-1')
+  expect(config.current_guild).toBe('guild-1')
+})

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

@@ -0,0 +1,129 @@
+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 listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+    const guilds = Object.values(config.guilds)
+
+    const output = guilds.map((guild) => ({
+      id: guild.guild_id,
+      name: guild.guild_name,
+      current: guild.guild_id === config.current_guild,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(guildId: 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 guild = await client.getGuild(guildId)
+
+    const output = {
+      id: guild.id,
+      name: guild.name,
+      icon: guild.icon,
+      owner: guild.owner,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function switchAction(guildId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.guilds[guildId]) {
+      console.log(formatOutput({ error: `Guild not found: ${guildId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    await credManager.setCurrentGuild(guildId)
+    console.log(formatOutput({ current: guildId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function currentAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.current_guild) {
+      console.log(
+        formatOutput({ error: 'No current guild set. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const guild = config.guilds[config.current_guild]
+
+    if (!guild) {
+      console.log(
+        formatOutput({ error: 'Current guild not found in configuration.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const output = {
+      guild_id: guild.guild_id,
+      guild_name: guild.guild_name,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const guildCommand = new Command('guild')
+  .description('Guild management commands')
+  .addCommand(
+    new Command('list')
+      .description('List all guilds')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get guild info')
+      .argument('<guild-id>', 'Guild ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('switch')
+      .description('Switch to guild')
+      .argument('<guild-id>', 'Guild ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(switchAction)
+  )
+  .addCommand(
+    new Command('current')
+      .description('Show current guild')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(currentAction)
+  )

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

@@ -0,0 +1,8 @@
+export { authCommand } from './auth'
+export { channelCommand } from './channel'
+export { fileCommand } from './file'
+export { guildCommand } from './guild'
+export { messageCommand } from './message'
+export { reactionCommand } from './reaction'
+export { snapshotCommand } from './snapshot'
+export { userCommand } from './user'