agent-messenger 1.0.0 → 1.2.0

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

@@ -16,27 +16,27 @@ export async function snapshotAction(options: {
     const credManager = new DiscordCredentialManager()
     const config = await credManager.load()
 
-    if (!config.token || !config.current_guild) {
+    if (!config.token || !config.current_server) {
       console.log(
-        formatOutput({ error: 'No current guild set. Run "guild switch" first.' }, options.pretty)
+        formatOutput({ error: 'No current server set. Run "server switch" first.' }, options.pretty)
       )
       process.exit(1)
     }
 
     const client = new DiscordClient(config.token as string)
-    const guildId = config.current_guild as string
+    const serverId = config.current_server 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,
+    const server = await client.getServer(serverId)
+    snapshot.server = {
+      id: server.id,
+      name: server.name,
     }
 
     if (!options.usersOnly) {
-      const channels = await client.listChannels(guildId)
+      const channels = await client.listChannels(serverId)
 
       snapshot.channels = channels.map((ch) => ({
         id: ch.id,
@@ -73,7 +73,7 @@ export async function snapshotAction(options: {
     }
 
     if (!options.channelsOnly) {
-      const users = await client.listUsers(guildId)
+      const users = await client.listUsers(serverId)
 
       snapshot.members = users.map((u) => ({
         id: u.id,
@@ -90,7 +90,7 @@ export async function snapshotAction(options: {
 
 export const snapshotCommand = new Command()
   .name('snapshot')
-  .description('Get comprehensive guild state for AI agents')
+  .description('Get comprehensive server 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')

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

@@ -0,0 +1,121 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+let clientCreateThreadSpy: ReturnType<typeof spyOn>
+let clientArchiveThreadSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  clientCreateThreadSpy = spyOn(DiscordClient.prototype, 'createThread').mockResolvedValue({
+    id: 'thread-1',
+    guild_id: 'guild-1',
+    name: 'Test Thread',
+    type: 11,
+    parent_id: 'ch-1',
+  })
+
+  clientArchiveThreadSpy = spyOn(DiscordClient.prototype, 'archiveThread').mockResolvedValue({
+    id: 'thread-1',
+    guild_id: 'guild-1',
+    name: 'Test Thread',
+    type: 11,
+    parent_id: 'ch-1',
+    thread_metadata: {
+      archived: true,
+      auto_archive_duration: 1440,
+      archive_timestamp: '2024-01-29T10:00:00Z',
+    },
+  })
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'server-1',
+    servers: {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+    },
+  })
+})
+
+afterEach(() => {
+  clientCreateThreadSpy?.mockRestore()
+  clientArchiveThreadSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+test('createThread: creates thread with name', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: creating thread
+  const thread = await client.createThread('ch-1', 'Test Thread')
+
+  // then: thread is created
+  expect(thread).toBeDefined()
+  expect(thread.id).toBe('thread-1')
+  expect(thread.name).toBe('Test Thread')
+  expect(thread.type).toBe(11)
+  expect(thread.parent_id).toBe('ch-1')
+})
+
+test('createThread: creates thread with auto_archive_duration', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: creating thread with auto_archive_duration
+  await client.createThread('ch-1', 'Test Thread', { auto_archive_duration: 60 })
+
+  // then: createThread is called with options
+  expect(clientCreateThreadSpy).toHaveBeenCalledWith('ch-1', 'Test Thread', {
+    auto_archive_duration: 60,
+  })
+})
+
+test('createThread: creates thread with rate_limit_per_user', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: creating thread with rate_limit_per_user
+  await client.createThread('ch-1', 'Test Thread', { rate_limit_per_user: 10 })
+
+  // then: createThread is called with options
+  expect(clientCreateThreadSpy).toHaveBeenCalledWith('ch-1', 'Test Thread', {
+    rate_limit_per_user: 10,
+  })
+})
+
+test('archiveThread: archives thread', async () => {
+  // given: discord client
+  const client = new DiscordClient('test-token')
+
+  // when: archiving thread
+  const thread = await client.archiveThread('thread-1')
+
+  // then: thread is archived
+  expect(thread).toBeDefined()
+  expect(thread.id).toBe('thread-1')
+  expect(thread.thread_metadata?.archived).toBe(true)
+})
+
+test('archiveThread: unarchives thread when archived=false', async () => {
+  // given: discord client with unarchive mock
+  clientArchiveThreadSpy.mockResolvedValue({
+    id: 'thread-1',
+    guild_id: 'guild-1',
+    name: 'Test Thread',
+    type: 11,
+    parent_id: 'ch-1',
+    thread_metadata: {
+      archived: false,
+      auto_archive_duration: 1440,
+    },
+  })
+  const client = new DiscordClient('test-token')
+
+  // when: unarchiving thread
+  const thread = await client.archiveThread('thread-1', false)
+
+  // then: thread is unarchived
+  expect(thread).toBeDefined()
+  expect(thread.thread_metadata?.archived).toBe(false)
+})

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

@@ -0,0 +1,92 @@
+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 createAction(
+  channelId: string,
+  name: string,
+  options: { autoArchiveDuration?: 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 threadOptions: { auto_archive_duration?: number } = {}
+
+    if (options.autoArchiveDuration) {
+      threadOptions.auto_archive_duration = parseInt(options.autoArchiveDuration, 10)
+    }
+
+    const thread = await client.createThread(channelId, name, threadOptions)
+
+    const output = {
+      id: thread.id,
+      name: thread.name,
+      type: thread.type,
+      parent_id: thread.parent_id,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function archiveAction(
+  threadId: 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 thread = await client.archiveThread(threadId)
+
+    const output = {
+      id: thread.id,
+      name: thread.name,
+      archived: thread.thread_metadata?.archived || false,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const threadCommand = new Command('thread')
+  .description('Thread commands')
+  .addCommand(
+    new Command('create')
+      .description('Create a thread')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<name>', 'Thread name')
+      .option('--auto-archive-duration <minutes>', 'Auto archive duration in minutes')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction)
+  )
+  .addCommand(
+    new Command('archive')
+      .description('Archive a thread')
+      .argument('<thread-id>', 'Thread ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(archiveAction)
+  )

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

@@ -16,7 +16,7 @@ const mockClient = {
     avatar: 'avatar_hash',
     bot: false,
   })),
-  listUsers: mock(async (_guildId: string) => [
+  listUsers: mock(async (_serverId: string) => [
     {
       id: 'user1',
       username: 'alice',
@@ -80,12 +80,12 @@ test('info returns user details by id', async () => {
   expect(result.username).toBe('testuser')
 })
 
-test('list returns guild members', async () => {
-  // given: guild id
-  const guildId = 'guild123'
+test('list returns server members', async () => {
+  // given: server id
+  const serverId = 'server123'
 
   // when: listing users
-  const users = await mockClient.listUsers(guildId)
+  const users = await mockClient.listUsers(serverId)
   const result = users.map((u) => ({
     id: u.id,
     username: u.username,
@@ -102,9 +102,9 @@ test('list returns guild members', async () => {
 })
 
 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)
+  // given: server id and users with bots
+  const serverId = 'server123'
+  const users = await mockClient.listUsers(serverId)
 
   // when: filtering out bots
   const filtered = users.filter((u) => !u.bot)

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

@@ -3,6 +3,7 @@ import { handleError } from '../../../shared/utils/error-handler'
 import { formatOutput } from '../../../shared/utils/output'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import type { DiscordUser } from '../types'
 
 async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -16,10 +17,10 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
       process.exit(1)
     }
 
-    if (!config.current_guild) {
+    if (!config.current_server) {
       console.log(
         formatOutput(
-          { error: 'No current guild set. Run "guild switch <id>" first.' },
+          { error: 'No current server set. Run "server switch <id>" first.' },
           options.pretty
         )
       )
@@ -27,7 +28,7 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
     }
 
     const client = new DiscordClient(config.token)
-    const users = await client.listUsers(config.current_guild)
+    const users = await client.listUsers(config.current_server)
 
     const output = users.map((user) => ({
       id: user.id,
@@ -56,7 +57,17 @@ async function infoAction(userId: string, options: { pretty?: boolean }): Promis
     }
 
     const client = new DiscordClient(config.token)
-    const user = await client.getUser(userId)
+
+    // Check if requesting current user - use @me endpoint (works with user tokens)
+    const me = await client.testAuth()
+    let user: DiscordUser
+
+    if (userId === me.id) {
+      user = me
+    } else {
+      // For other users, try the regular endpoint (requires bot token)
+      user = await client.getUser(userId)
+    }
 
     const output = {
       id: user.id,
@@ -105,7 +116,7 @@ export const userCommand = new Command('user')
   .description('User commands')
   .addCommand(
     new Command('list')
-      .description('List guild members')
+      .description('List server members')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction)
   )

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

@@ -1,173 +1,174 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { existsSync } from 'node:fs'
-import { rm } from 'node:fs/promises'
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 import { DiscordCredentialManager } from './credential-manager'
 
-const TEST_CONFIG_DIR = '/tmp/discord-test-config'
+const testDirs: string[] = []
 
-beforeEach(async () => {
-  if (existsSync(TEST_CONFIG_DIR)) {
-    await rm(TEST_CONFIG_DIR, { recursive: true })
-  }
-})
+function setup(): DiscordCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-discord-config-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  )
+  testDirs.push(testConfigDir)
+  return new DiscordCredentialManager(testConfigDir)
+}
 
-afterEach(async () => {
-  if (existsSync(TEST_CONFIG_DIR)) {
-    await rm(TEST_CONFIG_DIR, { recursive: true })
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
   }
 })
 
-test('load returns default config when file does not exist', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  const config = await manager.load()
+describe('DiscordCredentialManager', () => {
+  test('load returns default config when file does not exist', async () => {
+    const manager = setup()
+    const config = await manager.load()
 
-  expect(config).toEqual({
-    token: null,
-    current_guild: null,
-    guilds: {},
+    expect(config).toEqual({
+      token: null,
+      current_server: null,
+      servers: {},
+    })
   })
-})
-
-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('save creates config file with correct permissions', async () => {
+    const testConfigDir = join(
+      import.meta.dir,
+      `.test-discord-config-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    )
+    testDirs.push(testConfigDir)
+    const manager = new DiscordCredentialManager(testConfigDir)
+    const config = {
+      token: 'test-token',
+      current_server: 'server-123',
+      servers: {
+        'server-123': { server_id: 'server-123', server_name: 'Test Server' },
+      },
+    }
+
+    await manager.save(config)
+
+    const credentialsPath = join(testConfigDir, '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 previously set token', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  await manager.setToken('my-token')
+  test('getToken returns null when not authenticated', async () => {
+    const manager = setup()
+    const token = await manager.getToken()
+    expect(token).toBeNull()
+  })
 
-  const token = await manager.getToken()
-  expect(token).toBe('my-token')
-})
+  test('setToken saves token to config', async () => {
+    const manager = setup()
+    await manager.setToken('test-token-123')
 
-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).toBe('test-token-123')
+  })
 
-  const token = await manager.getToken()
-  expect(token).toBeNull()
-})
+  test('getToken returns previously set token', async () => {
+    const manager = setup()
+    await manager.setToken('my-token')
 
-test('getCurrentGuild returns null when not set', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  const guild = await manager.getCurrentGuild()
+    const token = await manager.getToken()
+    expect(token).toBe('my-token')
+  })
 
-  expect(guild).toBeNull()
-})
+  test('clearToken removes token from config', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
+    await manager.clearToken()
 
-test('setCurrentGuild saves guild id', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  await manager.setCurrentGuild('guild-456')
+    const token = await manager.getToken()
+    expect(token).toBeNull()
+  })
 
-  const guild = await manager.getCurrentGuild()
-  expect(guild).toBe('guild-456')
-})
+  test('getCurrentServer returns null when not set', async () => {
+    const manager = setup()
+    const server = await manager.getCurrentServer()
+    expect(server).toBeNull()
+  })
 
-test('getGuilds returns empty object when no guilds set', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  const guilds = await manager.getGuilds()
+  test('setCurrentServer saves server id', async () => {
+    const manager = setup()
+    await manager.setCurrentServer('server-456')
 
-  expect(guilds).toEqual({})
-})
+    const server = await manager.getCurrentServer()
+    expect(server).toBe('server-456')
+  })
 
-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' },
-  }
+  test('getServers returns empty object when no servers set', async () => {
+    const manager = setup()
+    const servers = await manager.getServers()
+    expect(servers).toEqual({})
+  })
 
-  await manager.setGuilds(guilds)
+  test('setServers saves servers to config', async () => {
+    const manager = setup()
+    const servers = {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+      'server-2': { server_id: 'server-2', server_name: 'Server Two' },
+    }
 
-  const loaded = await manager.getGuilds()
-  expect(loaded).toEqual(guilds)
-})
+    await manager.setServers(servers)
 
-test('getCredentials returns null when not authenticated', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
-  const creds = await manager.getCredentials()
+    const loaded = await manager.getServers()
+    expect(loaded).toEqual(servers)
+  })
 
-  expect(creds).toBeNull()
-})
+  test('getCredentials returns null when not authenticated', async () => {
+    const manager = setup()
+    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')
+  test('getCredentials returns null when token exists but no server selected', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
 
-  const creds = await manager.getCredentials()
-  expect(creds).toBeNull()
-})
+    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')
+  test('getCredentials returns null when server selected but no token', async () => {
+    const manager = setup()
+    await manager.setCurrentServer('server-123')
 
-  const creds = await manager.getCredentials()
-  expect(creds).toBeNull()
-})
+    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')
+  test('getCredentials returns token and serverId when both are set', async () => {
+    const manager = setup()
+    await manager.setToken('test-token-xyz')
+    await manager.setCurrentServer('server-789')
 
-  const creds = await manager.getCredentials()
-  expect(creds).toEqual({
-    token: 'test-token-xyz',
-    guildId: 'guild-789',
+    const creds = await manager.getCredentials()
+    expect(creds).toEqual({
+      token: 'test-token-xyz',
+      serverId: 'server-789',
+    })
   })
-})
 
-test('multiple operations preserve existing data', async () => {
-  const manager = new DiscordCredentialManager(TEST_CONFIG_DIR)
+  test('multiple operations preserve existing data', async () => {
+    const manager = setup()
+    await manager.setToken('token-1')
+    await manager.setCurrentServer('server-1')
+    const servers = {
+      'server-1': { server_id: 'server-1', server_name: 'Server One' },
+    }
+    await manager.setServers(servers)
 
-  // 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)
+    await manager.setToken('token-2')
 
-  // 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)
+    expect(await manager.getToken()).toBe('token-2')
+    expect(await manager.getCurrentServer()).toBe('server-1')
+    expect(await manager.getServers()).toEqual(servers)
+  })
 })