agent-messenger 1.0.0

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

@@ -0,0 +1,115 @@
+import { expect, mock, test } from 'bun:test'
+
+// Mock DiscordClient
+const mockClient = {
+  testAuth: mock(async () => ({
+    id: 'user123',
+    username: 'testuser',
+    global_name: 'Test User',
+    avatar: 'avatar_hash',
+    bot: false,
+  })),
+  getUser: mock(async (userId: string) => ({
+    id: userId,
+    username: 'testuser',
+    global_name: 'Test User',
+    avatar: 'avatar_hash',
+    bot: false,
+  })),
+  listUsers: mock(async (_guildId: string) => [
+    {
+      id: 'user1',
+      username: 'alice',
+      global_name: 'Alice',
+      avatar: 'avatar1',
+      bot: false,
+    },
+    {
+      id: 'user2',
+      username: 'bot_user',
+      global_name: 'Bot User',
+      avatar: 'avatar2',
+      bot: true,
+    },
+    {
+      id: 'user3',
+      username: 'bob',
+      global_name: 'Bob',
+      avatar: 'avatar3',
+      bot: false,
+    },
+  ]),
+}
+
+test('me returns current user info', async () => {
+  // given: authenticated user
+  const user = await mockClient.testAuth()
+
+  // when: getting current user
+  const result = {
+    id: user.id,
+    username: user.username,
+    global_name: user.global_name,
+    avatar: user.avatar,
+    bot: user.bot,
+  }
+
+  // then: returns user object
+  expect(result.id).toBe('user123')
+  expect(result.username).toBe('testuser')
+  expect(result.global_name).toBe('Test User')
+  expect(result.bot).toBe(false)
+})
+
+test('info returns user details by id', async () => {
+  // given: user id
+  const userId = 'user123'
+
+  // when: getting user info
+  const user = await mockClient.getUser(userId)
+  const result = {
+    id: user.id,
+    username: user.username,
+    global_name: user.global_name,
+    avatar: user.avatar,
+    bot: user.bot,
+  }
+
+  // then: returns user object
+  expect(result.id).toBe('user123')
+  expect(result.username).toBe('testuser')
+})
+
+test('list returns guild members', async () => {
+  // given: guild id
+  const guildId = 'guild123'
+
+  // when: listing users
+  const users = await mockClient.listUsers(guildId)
+  const result = users.map((u) => ({
+    id: u.id,
+    username: u.username,
+    global_name: u.global_name,
+    avatar: u.avatar,
+    bot: u.bot,
+  }))
+
+  // then: returns array of users
+  expect(result).toHaveLength(3)
+  expect(result[0].username).toBe('alice')
+  expect(result[1].bot).toBe(true)
+  expect(result[2].username).toBe('bob')
+})
+
+test('list filters out bots when flag not set', async () => {
+  // given: guild id and users with bots
+  const guildId = 'guild123'
+  const users = await mockClient.listUsers(guildId)
+
+  // when: filtering out bots
+  const filtered = users.filter((u) => !u.bot)
+
+  // then: returns only non-bot users
+  expect(filtered).toHaveLength(2)
+  expect(filtered.every((u) => !u.bot)).toBe(true)
+})

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

@@ -0,0 +1,124 @@
+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'
+
+async function listAction(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)
+    }
+
+    if (!config.current_guild) {
+      console.log(
+        formatOutput(
+          { error: 'No current guild set. Run "guild switch <id>" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new DiscordClient(config.token)
+    const users = await client.listUsers(config.current_guild)
+
+    const output = users.map((user) => ({
+      id: user.id,
+      username: user.username,
+      global_name: user.global_name,
+      avatar: user.avatar,
+      bot: user.bot,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function infoAction(userId: 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 user = await client.getUser(userId)
+
+    const output = {
+      id: user.id,
+      username: user.username,
+      global_name: user.global_name,
+      avatar: user.avatar,
+      bot: user.bot,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function meAction(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 user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      username: user.username,
+      global_name: user.global_name,
+      avatar: user.avatar,
+      bot: user.bot,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const userCommand = new Command('user')
+  .description('User commands')
+  .addCommand(
+    new Command('list')
+      .description('List guild members')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get user info')
+      .argument('<user-id>', 'User ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('me')
+      .description('Show current authenticated user')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(meAction)
+  )

package/src/platforms/discord/credential-manager.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { existsSync } from 'node:fs'
+import { rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { DiscordCredentialManager } from './credential-manager'
+
+const TEST_CONFIG_DIR = '/tmp/discord-test-config'
+
+beforeEach(async () => {
+  if (existsSync(TEST_CONFIG_DIR)) {
+    await rm(TEST_CONFIG_DIR, { recursive: true })
+  }
+})
+
+afterEach(async () => {
+  if (existsSync(TEST_CONFIG_DIR)) {
+    await rm(TEST_CONFIG_DIR, { recursive: true })
+  }
+})
+
+test('load returns default config when file does not exist', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const config = await manager.load()
+
+  expect(config).toEqual({
+    token: null,
+    current_guild: null,
+    guilds: {},
+  })
+})
+
+test('save creates config file with correct permissions', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const config = {
+    token: 'test-token',
+    current_guild: 'guild-123',
+    guilds: {
+      'guild-123': { guild_id: 'guild-123', guild_name: 'Test Guild' },
+    },
+  }
+
+  await manager.save(config)
+
+  const credentialsPath = join(TEST_CONFIG_DIR, 'discord-credentials.json')
+  expect(existsSync(credentialsPath)).toBe(true)
+
+  const file = Bun.file(credentialsPath)
+  const content = await file.text()
+  const loaded = JSON.parse(content)
+  expect(loaded).toEqual(config)
+})
+
+test('getToken returns null when not authenticated', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const token = await manager.getToken()
+
+  expect(token).toBeNull()
+})
+
+test('setToken saves token to config', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setToken('test-token-123')
+
+  const token = await manager.getToken()
+  expect(token).toBe('test-token-123')
+})
+
+test('getToken returns previously set token', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setToken('my-token')
+
+  const token = await manager.getToken()
+  expect(token).toBe('my-token')
+})
+
+test('clearToken removes token from config', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setToken('test-token')
+  await manager.clearToken()
+
+  const token = await manager.getToken()
+  expect(token).toBeNull()
+})
+
+test('getCurrentGuild returns null when not set', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const guild = await manager.getCurrentGuild()
+
+  expect(guild).toBeNull()
+})
+
+test('setCurrentGuild saves guild id', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setCurrentGuild('guild-456')
+
+  const guild = await manager.getCurrentGuild()
+  expect(guild).toBe('guild-456')
+})
+
+test('getGuilds returns empty object when no guilds set', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const guilds = await manager.getGuilds()
+
+  expect(guilds).toEqual({})
+})
+
+test('setGuilds saves guilds to config', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const guilds = {
+    'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
+    'guild-2': { guild_id: 'guild-2', guild_name: 'Guild Two' },
+  }
+
+  await manager.setGuilds(guilds)
+
+  const loaded = await manager.getGuilds()
+  expect(loaded).toEqual(guilds)
+})
+
+test('getCredentials returns null when not authenticated', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  const creds = await manager.getCredentials()
+
+  expect(creds).toBeNull()
+})
+
+test('getCredentials returns null when token exists but no guild selected', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setToken('test-token')
+
+  const creds = await manager.getCredentials()
+  expect(creds).toBeNull()
+})
+
+test('getCredentials returns null when guild selected but no token', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setCurrentGuild('guild-123')
+
+  const creds = await manager.getCredentials()
+  expect(creds).toBeNull()
+})
+
+test('getCredentials returns token and guildId when both are set', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  await manager.setToken('test-token-xyz')
+  await manager.setCurrentGuild('guild-789')
+
+  const creds = await manager.getCredentials()
+  expect(creds).toEqual({
+    token: 'test-token-xyz',
+    guildId: 'guild-789',
+  })
+})
+
+test('multiple operations preserve existing data', async () => {
+  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+
+  // Set initial data
+  await manager.setToken('token-1')
+  await manager.setCurrentGuild('guild-1')
+  const guilds = {
+    'guild-1': { guild_id: 'guild-1', guild_name: 'Guild One' },
+  }
+  await manager.setGuilds(guilds)
+
+  // Update token
+  await manager.setToken('token-2')
+
+  // Verify all data is preserved
+  expect(await manager.getToken()).toBe('token-2')
+  expect(await manager.getCurrentGuild()).toBe('guild-1')
+  expect(await manager.getGuilds()).toEqual(guilds)
+})

package/src/platforms/discord/credential-manager.ts

@@ -0,0 +1,95 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export interface DiscordConfig {
+  token: string | null
+  current_guild: string | null
+  guilds: Record<string, { guild_id: string; guild_name: string }>
+}
+
+export class DiscordCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'discord-credentials.json')
+  }
+
+  async load(): Promise<DiscordConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return {
+        token: null,
+        current_guild: null,
+        guilds: {},
+      }
+    }
+
+    const file = Bun.file(this.credentialsPath)
+    const content = await file.text()
+    return JSON.parse(content) as DiscordConfig
+  }
+
+  async save(config: DiscordConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+
+    const file = Bun.file(this.credentialsPath)
+    await Bun.write(file, JSON.stringify(config, null, 2))
+
+    await Bun.spawn(['chmod', '0600', this.credentialsPath]).exited
+  }
+
+  async getToken(): Promise<string | null> {
+    const config = await this.load()
+    return config.token
+  }
+
+  async setToken(token: string): Promise<void> {
+    const config = await this.load()
+    config.token = token
+    await this.save(config)
+  }
+
+  async clearToken(): Promise<void> {
+    const config = await this.load()
+    config.token = null
+    await this.save(config)
+  }
+
+  async getCurrentGuild(): Promise<string | null> {
+    const config = await this.load()
+    return config.current_guild
+  }
+
+  async setCurrentGuild(guildId: string): Promise<void> {
+    const config = await this.load()
+    config.current_guild = guildId
+    await this.save(config)
+  }
+
+  async getGuilds(): Promise<Record<string, { guild_id: string; guild_name: string }>> {
+    const config = await this.load()
+    return config.guilds
+  }
+
+  async setGuilds(guilds: Record<string, { guild_id: string; guild_name: string }>): Promise<void> {
+    const config = await this.load()
+    config.guilds = guilds
+    await this.save(config)
+  }
+
+  async getCredentials(): Promise<{ token: string; guildId: string } | null> {
+    const config = await this.load()
+
+    if (!config.token || !config.current_guild) {
+      return null
+    }
+
+    return {
+      token: config.token,
+      guildId: config.current_guild,
+    }
+  }
+}