agent-messenger 1.0.0

package/src/platforms/discord/client.ts

@@ -0,0 +1,281 @@
+import type {
+  DiscordChannel,
+  DiscordFile,
+  DiscordGuild,
+  DiscordMessage,
+  DiscordUser,
+} from './types'
+
+export class DiscordError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'DiscordError'
+    this.code = code
+  }
+}
+
+interface RateLimitBucket {
+  remaining: number
+  resetAt: number
+  bucketHash: string
+}
+
+const BASE_URL = 'https://discord.com/api/v10'
+const MAX_RETRIES = 3
+const BASE_BACKOFF_MS = 100
+
+export class DiscordClient {
+  private token: string
+  private buckets: Map<string, RateLimitBucket> = new Map()
+  private globalRateLimitUntil: number = 0
+
+  constructor(token: string) {
+    if (!token) {
+      throw new DiscordError('Token is required', 'missing_token')
+    }
+    this.token = token
+  }
+
+  private getBucketKey(method: string, path: string): string {
+    const normalized = path
+      .replace(/\/channels\/\d+/, '/channels/{channel_id}')
+      .replace(/\/guilds\/\d+/, '/guilds/{guild_id}')
+      .replace(/\/users\/\d+/, '/users/{user_id}')
+      .replace(/\/messages\/\d+/, '/messages/{message_id}')
+    return `${method}:${normalized}`
+  }
+
+  private async waitForRateLimit(bucketKey: string): Promise<void> {
+    const now = Date.now()
+
+    if (this.globalRateLimitUntil > now) {
+      await this.sleep(this.globalRateLimitUntil - now)
+    }
+
+    const bucket = this.buckets.get(bucketKey)
+    if (bucket && bucket.remaining === 0 && bucket.resetAt * 1000 > now) {
+      await this.sleep(bucket.resetAt * 1000 - now)
+    }
+  }
+
+  private updateBucket(bucketKey: string, response: Response): void {
+    const remaining = response.headers.get('X-RateLimit-Remaining')
+    const reset = response.headers.get('X-RateLimit-Reset')
+    const bucketHash = response.headers.get('X-RateLimit-Bucket')
+
+    if (remaining !== null && reset !== null && bucketHash !== null) {
+      this.buckets.set(bucketKey, {
+        remaining: parseInt(remaining, 10),
+        resetAt: parseFloat(reset),
+        bucketHash,
+      })
+    }
+  }
+
+  private async handleRateLimitResponse(response: Response): Promise<number> {
+    const retryAfter = response.headers.get('Retry-After')
+    const isGlobal = response.headers.get('X-RateLimit-Global') === 'true'
+    const waitMs = parseFloat(retryAfter || '1') * 1000
+
+    if (isGlobal) {
+      this.globalRateLimitUntil = Date.now() + waitMs
+    }
+
+    await this.sleep(waitMs)
+    return waitMs
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const url = `${BASE_URL}${path}`
+    const bucketKey = this.getBucketKey(method, path)
+    let lastError: Error | undefined
+
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      await this.waitForRateLimit(bucketKey)
+
+      const headers: Record<string, string> = {
+        Authorization: this.token,
+        'Content-Type': 'application/json',
+      }
+
+      const options: RequestInit = {
+        method,
+        headers,
+      }
+
+      if (body !== undefined) {
+        options.body = JSON.stringify(body)
+      }
+
+      const response = await fetch(url, options)
+      this.updateBucket(bucketKey, response)
+
+      if (response.status === 429) {
+        if (attempt < MAX_RETRIES) {
+          await this.handleRateLimitResponse(response)
+          continue
+        }
+        const errorBody = await response.json().catch(() => ({}))
+        throw new DiscordError((errorBody as any).message || 'Rate limited', 'rate_limited')
+      }
+
+      if (response.status >= 500 && attempt < MAX_RETRIES) {
+        await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+        continue
+      }
+
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}))
+        throw new DiscordError(
+          (errorBody as any).message || `HTTP ${response.status}`,
+          (errorBody as any).code?.toString() || `http_${response.status}`
+        )
+      }
+
+      if (response.status === 204) {
+        return undefined as T
+      }
+
+      return response.json() as Promise<T>
+    }
+
+    throw lastError || new DiscordError('Request failed after retries', 'max_retries')
+  }
+
+  private async requestFormData<T>(path: string, formData: FormData): Promise<T> {
+    const url = `${BASE_URL}${path}`
+    const bucketKey = this.getBucketKey('POST', path)
+
+    await this.waitForRateLimit(bucketKey)
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: this.token,
+      },
+      body: formData,
+    })
+
+    this.updateBucket(bucketKey, response)
+
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}))
+      throw new DiscordError(
+        (errorBody as any).message || `HTTP ${response.status}`,
+        (errorBody as any).code?.toString() || `http_${response.status}`
+      )
+    }
+
+    return response.json() as Promise<T>
+  }
+
+  async testAuth(): Promise<DiscordUser> {
+    return this.request<DiscordUser>('GET', '/users/@me')
+  }
+
+  async listGuilds(): Promise<DiscordGuild[]> {
+    return this.request<DiscordGuild[]>('GET', '/users/@me/guilds')
+  }
+
+  async getGuild(guildId: string): Promise<DiscordGuild> {
+    return this.request<DiscordGuild>('GET', `/guilds/${guildId}`)
+  }
+
+  async listChannels(guildId: string): Promise<DiscordChannel[]> {
+    return this.request<DiscordChannel[]>('GET', `/guilds/${guildId}/channels`)
+  }
+
+  async getChannel(channelId: string): Promise<DiscordChannel> {
+    return this.request<DiscordChannel>('GET', `/channels/${channelId}`)
+  }
+
+  async sendMessage(channelId: string, content: string): Promise<DiscordMessage> {
+    return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, { content })
+  }
+
+  async getMessages(channelId: string, limit: number = 50): Promise<DiscordMessage[]> {
+    return this.request<DiscordMessage[]>('GET', `/channels/${channelId}/messages?limit=${limit}`)
+  }
+
+  async getMessage(channelId: string, messageId: string): Promise<DiscordMessage> {
+    return this.request<DiscordMessage>('GET', `/channels/${channelId}/messages/${messageId}`)
+  }
+
+  async deleteMessage(channelId: string, messageId: string): Promise<void> {
+    return this.request<void>('DELETE', `/channels/${channelId}/messages/${messageId}`)
+  }
+
+  async addReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
+    const encodedEmoji = encodeURIComponent(emoji)
+    return this.request<void>(
+      'PUT',
+      `/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}/@me`
+    )
+  }
+
+  async removeReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
+    const encodedEmoji = encodeURIComponent(emoji)
+    return this.request<void>(
+      'DELETE',
+      `/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}/@me`
+    )
+  }
+
+  async listUsers(guildId: string): Promise<DiscordUser[]> {
+    interface GuildMember {
+      user: DiscordUser
+    }
+    const members = await this.request<GuildMember[]>(
+      'GET',
+      `/guilds/${guildId}/members?limit=1000`
+    )
+    return members.map((m) => m.user)
+  }
+
+  async getUser(userId: string): Promise<DiscordUser> {
+    return this.request<DiscordUser>('GET', `/users/${userId}`)
+  }
+
+  async uploadFile(channelId: string, filePath: string): Promise<DiscordFile> {
+    const file = Bun.file(filePath)
+    const filename = filePath.split('/').pop() || 'file'
+    const blob = await file.arrayBuffer()
+
+    const formData = new FormData()
+    formData.append('files[0]', new Blob([blob]), filename)
+
+    interface MessageWithAttachments extends DiscordMessage {
+      attachments: DiscordFile[]
+    }
+    const message = await this.requestFormData<MessageWithAttachments>(
+      `/channels/${channelId}/messages`,
+      formData
+    )
+
+    return message.attachments[0]
+  }
+
+  async listFiles(channelId: string): Promise<DiscordFile[]> {
+    interface MessageWithAttachments extends DiscordMessage {
+      attachments: DiscordFile[]
+    }
+    const messages = await this.request<MessageWithAttachments[]>(
+      'GET',
+      `/channels/${channelId}/messages?limit=100`
+    )
+
+    const files: DiscordFile[] = []
+    for (const msg of messages) {
+      if (msg.attachments && msg.attachments.length > 0) {
+        files.push(...msg.attachments)
+      }
+    }
+    return files
+  }
+}

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

@@ -0,0 +1,72 @@
+import { expect, mock, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { DiscordTokenExtractor } from '../token-extractor'
+
+// Mock modules
+mock.module('../token-extractor', () => ({
+  DiscordTokenExtractor: mock(() => ({
+    extract: mock(async () => ({
+      token: 'test-token-123',
+    })),
+  })),
+}))
+
+mock.module('../client', () => ({
+  DiscordClient: mock((_token: string) => ({
+    testAuth: mock(async () => ({
+      id: 'user-123',
+      username: 'testuser',
+    })),
+    listGuilds: mock(async () => [
+      { id: 'guild-1', name: 'Guild One' },
+      { id: 'guild-2', name: 'Guild Two' },
+    ]),
+  })),
+}))
+
+mock.module('../credential-manager', () => ({
+  DiscordCredentialManager: mock(() => ({
+    load: mock(async () => ({
+      token: null,
+      current_guild: null,
+      guilds: {},
+    })),
+    save: mock(async () => {}),
+    clearToken: mock(async () => {}),
+  })),
+}))
+
+test('extract: calls DiscordTokenExtractor', async () => {
+  const extractor = new DiscordTokenExtractor()
+  const result = await extractor.extract()
+  expect(result).toBeDefined()
+  expect(result?.token).toBe('test-token-123')
+})
+
+test('extract: validates token with DiscordClient', async () => {
+  const client = new DiscordClient('test-token-123')
+  const authInfo = await client.testAuth()
+  expect(authInfo).toBeDefined()
+  expect(authInfo.id).toBe('user-123')
+})
+
+test('extract: discovers guilds', async () => {
+  const client = new DiscordClient('test-token-123')
+  const guilds = await client.listGuilds()
+  expect(guilds).toHaveLength(2)
+  expect(guilds[0].id).toBe('guild-1')
+})
+
+test('logout: clears credentials', async () => {
+  const credManager = new DiscordCredentialManager()
+  await credManager.clearToken()
+  expect(credManager.clearToken).toHaveBeenCalled()
+})
+
+test('status: returns auth state', async () => {
+  const credManager = new DiscordCredentialManager()
+  const config = await credManager.load()
+  expect(config.token).toBeNull()
+  expect(config.current_guild).toBeNull()
+})

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

@@ -0,0 +1,206 @@
+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 { DiscordTokenExtractor } from '../token-extractor'
+
+export async function extractAction(options: { pretty?: boolean; debug?: boolean }): Promise<void> {
+  try {
+    const extractor = new DiscordTokenExtractor()
+
+    if (process.platform === 'darwin') {
+      console.log('')
+      console.log('  Extracting your Discord credentials...')
+      console.log('')
+      console.log('  Your Mac may ask for your password to access Keychain.')
+      console.log('  This is required because Discord encrypts your login token')
+      console.log('  using macOS Keychain for security.')
+      console.log('')
+      console.log('  What happens:')
+      console.log("    1. We read the encrypted token from Discord's local storage")
+      console.log('    2. macOS Keychain decrypts it (requires your password)')
+      console.log('    3. The token is stored locally in ~/.config/agent-messenger/')
+      console.log('')
+      console.log('  Your password is never stored or transmitted anywhere.')
+      console.log('')
+    }
+
+    if (options.debug) {
+      console.error(`[debug] Extracting Discord token...`)
+    }
+
+    const extracted = await extractor.extract()
+
+    if (!extracted) {
+      console.log(
+        formatOutput(
+          {
+            error:
+              'No Discord token found. Make sure Discord desktop app is installed and logged in.',
+            hint: options.debug ? undefined : 'Run with --debug for more info.',
+          },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    if (options.debug) {
+      console.error(`[debug] Token extracted: ${extracted.token.substring(0, 20)}...`)
+    }
+
+    try {
+      const client = new DiscordClient(extracted.token)
+
+      if (options.debug) {
+        console.error(`[debug] Testing token validity...`)
+      }
+
+      const authInfo = await client.testAuth()
+
+      if (options.debug) {
+        console.error(`[debug] ✓ Token valid for user: ${authInfo.username}`)
+        console.error(`[debug] Discovering guilds...`)
+      }
+
+      const guilds = await client.listGuilds()
+
+      if (options.debug) {
+        console.error(`[debug] ✓ Found ${guilds.length} guild(s)`)
+      }
+
+      if (guilds.length === 0) {
+        console.log(
+          formatOutput(
+            {
+              error: 'No guilds found. Make sure you are a member of at least one Discord server.',
+            },
+            options.pretty
+          )
+        )
+        process.exit(1)
+      }
+
+      const credManager = new DiscordCredentialManager()
+      const guildMap: Record<string, { guild_id: string; guild_name: string }> = {}
+
+      for (const guild of guilds) {
+        guildMap[guild.id] = {
+          guild_id: guild.id,
+          guild_name: guild.name,
+        }
+      }
+
+      const config = {
+        token: extracted.token,
+        current_guild: guilds[0].id,
+        guilds: guildMap,
+      }
+
+      await credManager.save(config)
+
+      if (options.debug) {
+        console.error(`[debug] ✓ Credentials saved`)
+      }
+
+      const output = {
+        guilds: guilds.map((g) => `${g.id}/${g.name}`),
+        current: guilds[0].id,
+      }
+
+      console.log(formatOutput(output, options.pretty))
+    } catch (error) {
+      console.log(
+        formatOutput(
+          {
+            error: `Token validation failed: ${(error as Error).message}`,
+            hint: 'Make sure your Discord token is valid and has not expired.',
+          },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function logoutAction(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)
+    }
+
+    await credManager.clearToken()
+
+    console.log(formatOutput({ removed: 'discord', success: true }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function statusAction(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)
+    }
+
+    let authInfo: { id: string; username: string } | null = null
+    let valid = false
+
+    try {
+      const client = new DiscordClient(config.token)
+      authInfo = await client.testAuth()
+      valid = true
+    } catch {
+      valid = false
+    }
+
+    const output = {
+      authenticated: valid,
+      user: authInfo?.username,
+      current_guild: config.current_guild,
+      guilds_count: Object.keys(config.guilds).length,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Authentication commands')
+  .addCommand(
+    new Command('extract')
+      .description('Extract token from Discord desktop app')
+      .option('--pretty', 'Pretty print JSON output')
+      .option('--debug', 'Show debug output for troubleshooting')
+      .action(extractAction)
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Logout from Discord')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction)
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction)
+  )

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

@@ -0,0 +1,153 @@
+import { expect, mock, test } from 'bun:test'
+import { DiscordClient } from '../client'
+
+// Mock modules
+mock.module('../client', () => ({
+  DiscordClient: mock((_token: string) => ({
+    listChannels: mock(async (guildId: string) => [
+      { id: 'ch-1', guild_id: guildId, name: 'general', type: 0, topic: 'General discussion' },
+      { id: 'ch-2', guild_id: guildId, name: 'announcements', type: 0, topic: 'Announcements' },
+      { id: 'ch-3', guild_id: guildId, name: 'voice-channel', type: 2, topic: null },
+    ]),
+    getChannel: mock(async (channelId: string) => {
+      if (channelId === 'ch-1') {
+        return {
+          id: 'ch-1',
+          guild_id: 'guild-1',
+          name: 'general',
+          type: 0,
+          topic: 'General discussion',
+        }
+      }
+      if (channelId === 'ch-2') {
+        return {
+          id: 'ch-2',
+          guild_id: 'guild-1',
+          name: 'announcements',
+          type: 0,
+          topic: 'Announcements',
+        }
+      }
+      throw new Error('Channel not found')
+    }),
+    getMessages: mock(async (channelId: string, _limit: number) => [
+      {
+        id: 'msg-1',
+        channel_id: channelId,
+        author: { id: 'user-1', username: 'alice' },
+        content: 'Hello world',
+        timestamp: '2024-01-29T10:00:00Z',
+      },
+      {
+        id: 'msg-2',
+        channel_id: channelId,
+        author: { id: 'user-2', username: 'bob' },
+        content: 'Hi there',
+        timestamp: '2024-01-29T09:00:00Z',
+      },
+    ]),
+  })),
+}))
+
+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' },
+      },
+    })),
+  })),
+}))
+
+test('list: returns text channels (type=0) from guild', async () => {
+  // given: discord client with channels
+  const client = new DiscordClient('test-token')
+  const channels = await client.listChannels('guild-1')
+
+  // when: filtering text channels
+  const textChannels = channels.filter((ch) => ch.type === 0)
+
+  // then: only text channels are returned
+  expect(textChannels).toHaveLength(2)
+  expect(textChannels[0].name).toBe('general')
+  expect(textChannels[1].name).toBe('announcements')
+})
+
+test('list: includes channel metadata', async () => {
+  // given: discord client with channels
+  const client = new DiscordClient('test-token')
+  const channels = await client.listChannels('guild-1')
+  const textChannels = channels.filter((ch) => ch.type === 0)
+
+  // when: checking channel properties
+  const channel = textChannels[0]
+
+  // then: channel has id, name, type, topic
+  expect(channel.id).toBeDefined()
+  expect(channel.name).toBeDefined()
+  expect(channel.type).toBe(0)
+  expect(channel.topic).toBeDefined()
+})
+
+test('info: returns channel details', async () => {
+  // given: discord client with channel data
+  const client = new DiscordClient('test-token')
+  const channel = await client.getChannel('ch-1')
+
+  // when: getting channel info
+  expect(channel).toBeDefined()
+
+  // then: channel details are returned
+  expect(channel.id).toBe('ch-1')
+  expect(channel.name).toBe('general')
+  expect(channel.type).toBe(0)
+  expect(channel.topic).toBe('General discussion')
+})
+
+test('info: throws error for non-existent channel', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: getting non-existent channel
+  // then: error is thrown
+  try {
+    await client.getChannel('non-existent')
+    expect(true).toBe(false) // should not reach here
+  } catch (error) {
+    expect((error as Error).message).toContain('Channel not found')
+  }
+})
+
+test('history: returns messages in reverse chronological order', async () => {
+  // given: discord client with messages
+  const client = new DiscordClient('test-token')
+  const messages = await client.getMessages('ch-1', 50)
+
+  // when: getting message history
+  expect(messages).toBeDefined()
+
+  // then: messages are returned (Discord API returns newest first)
+  expect(messages).toHaveLength(2)
+  expect(messages[0].id).toBe('msg-1')
+  expect(messages[0].author.username).toBe('alice')
+  expect(messages[1].id).toBe('msg-2')
+  expect(messages[1].author.username).toBe('bob')
+})
+
+test('history: includes message metadata', async () => {
+  // given: discord client with messages
+  const client = new DiscordClient('test-token')
+  const messages = await client.getMessages('ch-1', 50)
+
+  // when: checking message properties
+  const message = messages[0]
+
+  // then: message has id, content, author, timestamp
+  expect(message.id).toBeDefined()
+  expect(message.content).toBeDefined()
+  expect(message.author).toBeDefined()
+  expect(message.author.username).toBeDefined()
+  expect(message.timestamp).toBeDefined()
+})