agent-messenger 2.38.1 → 2.39.0

package/docs/content/docs/cli/discordbot.mdx

@@ -63,7 +63,7 @@ Without this, the bot won't receive message content in large servers.
 agent-discordbot auth set <token>
 
 # Set with a custom bot identifier for multi-bot setups
-agent-discordbot auth set <token> --bot deploy --name "Deploy Bot"
+agent-discordbot auth set <token> --bot deploy
 
 # Check bot auth status
 agent-discordbot auth status
@@ -87,8 +87,8 @@ Store multiple bot tokens and switch between them:
 
 ```bash
 # Add multiple bots
-agent-discordbot auth set deploy-bot-token --bot deploy --name "Deploy Bot"
-agent-discordbot auth set alert-bot-token --bot alert --name "Alert Bot"
+agent-discordbot auth set deploy-bot-token --bot deploy
+agent-discordbot auth set alert-bot-token --bot alert
 
 # List all stored bots
 agent-discordbot auth list
@@ -105,14 +105,15 @@ agent-discordbot auth remove deploy
 
 ### Permissions Reference
 
-| Permission           | Used For                            |
-| -------------------- | ----------------------------------- |
-| Send Messages        | Sending messages to channels        |
-| Read Message History | Reading past messages in channels   |
-| View Channels        | Listing and accessing channels      |
-| Add Reactions        | Adding and removing emoji reactions |
-| Attach Files         | Uploading files to channels         |
-| Manage Threads       | Creating and archiving threads      |
+| Permission               | Used For                                                                     |
+| ------------------------ | ---------------------------------------------------------------------------- |
+| Send Messages            | Sending messages to channels                                                 |
+| Send Messages in Threads | Posting into threads with `--thread` (`message send`, `file upload`)         |
+| Read Message History     | Reading past messages, replying with `--reply`, and `thread list --archived` |
+| View Channels            | Listing and accessing channels                                               |
+| Add Reactions            | Adding and removing emoji reactions                                          |
+| Attach Files             | Uploading files to channels and threads                                      |
+| Manage Threads           | Creating and archiving threads                                               |
 
 ### Environment Variables (CI/CD)
 
@@ -159,8 +160,12 @@ agent-discordbot message send general "Hello world"
 # Reply to a message
 agent-discordbot message send general "On it!" --reply 9876543210987654321
 
-# Send a message into a thread
-agent-discordbot message send general "Hello world" --thread 9876543210987654321
+# Send a message into a thread. --thread takes a thread ID or an active
+# thread name in that channel. The message lands in the thread, so the
+# response's channel_id is the thread ID, not the parent channel.
+agent-discordbot thread list general                     # find the thread ID
+agent-discordbot message send general "Hello" --thread 9876543210987654321
+agent-discordbot message send general "Hello" --thread "Release notes"
 
 # List messages
 agent-discordbot message list <channel>
@@ -196,7 +201,6 @@ agent-discordbot channel info general
 ```bash
 # List server members
 agent-discordbot user list
-agent-discordbot user list --limit 50
 
 # Get user info
 agent-discordbot user info <user-id>
@@ -211,19 +215,39 @@ agent-discordbot reaction add general 9876543210987654321 thumbsup
 
 # Remove reaction
 agent-discordbot reaction remove <channel> <message-id> <emoji>
+
+# List reactions on a message (emoji, count, and whether the bot reacted)
+agent-discordbot reaction list <channel> <message-id>
 ```
 
 ### File Commands
 
 ```bash
-# Upload file to a channel
-agent-discordbot file upload <channel> <file-path>
+# Upload one or more files (max 10) to a channel
+agent-discordbot file upload <channel> <file-path...> [--text <text>] [--thread <id|name>] [--reply <message-id>] [--filename <name>]
 agent-discordbot file upload general ./report.pdf
+agent-discordbot file upload general ./report.pdf ./chart.png --text "Weekly numbers"
+
+# Upload into a thread (same --thread rules as message send)
+agent-discordbot file upload general ./log.txt --thread "Release notes"
+
+# Upload as a reply to a message
+agent-discordbot file upload general ./fix.patch --reply 9876543210987654321
 
-# List files in channel
+# Override the filename (single file only)
+agent-discordbot file upload general ./tmp/abc123.txt --filename notes.txt
+
+# List files in channel (attachments of the latest 100 messages, one request)
 agent-discordbot file list <channel>
+
+# Get a single file by attachment ID (searches back through the latest 1,000 messages)
+agent-discordbot file info <channel> <file-id>
 ```
 
+`file list` reads a single page of channel history, so it stays fast on busy channels. `file info` pages further back with `before` cursors and stops at the first matching attachment; a file older than the latest 1,000 messages reports `File not found`.
+
+The upload response includes `message_id`, `channel_id` (the thread ID when `--thread` is used), and a `files` array with each attachment's `id`, `filename`, `size`, and `url`. Discord enforces the per-file size limit; oversized uploads come back as an error instead of being rejected locally.
+
 ### Thread Commands
 
 ```bash
@@ -231,6 +255,13 @@ agent-discordbot file list <channel>
 agent-discordbot thread create <channel> <name>
 agent-discordbot thread create general "Discussion" --auto-archive-duration 1440
 
+# List active threads in the server, or only those under one channel
+agent-discordbot thread list
+agent-discordbot thread list <channel>
+
+# List archived threads (a channel is required; returns up to 100 with has_more)
+agent-discordbot thread list <channel> --archived
+
 # Archive a thread
 agent-discordbot thread archive <thread-id>
 ```
@@ -269,16 +300,18 @@ With `--full`, returns comprehensive JSON with:
 
 ## Key Differences from agent-discord
 
-| Feature                     | agent-discord                   | agent-discordbot             |
-| --------------------------- | ------------------------------- | ---------------------------- |
-| Token type                  | User token                      | Bot token                    |
-| Token source                | Auto-extracted from desktop app | Manual from Developer Portal |
-| Message search              | Yes                             | No                           |
-| DM commands                 | Yes                             | No                           |
-| Mention/Friend/Note/Profile | Yes                             | No                           |
-| Thread management           | Yes                             | Yes                          |
-| Multi-bot support           | N/A                             | Yes (`--bot` flag)           |
-| CI/CD friendly              | Requires desktop app            | Yes                          |
+| Feature                     | agent-discord                   | agent-discordbot                           |
+| --------------------------- | ------------------------------- | ------------------------------------------ |
+| Token type                  | User token                      | Bot token                                  |
+| Token source                | Auto-extracted from desktop app | Manual from Developer Portal               |
+| Message search              | Yes                             | No                                         |
+| DM commands                 | Yes                             | No                                         |
+| Mention/Friend/Note/Profile | Yes                             | No                                         |
+| Thread management           | Yes                             | Yes (create, list, archive)                |
+| File upload                 | Yes                             | Yes (multi-file, into threads, as replies) |
+| Reactions                   | Yes                             | Yes (add, remove, list)                    |
+| Multi-bot support           | N/A                             | Yes (`--bot` flag)                         |
+| CI/CD friendly              | Requires desktop app            | Yes                                        |
 
 ## Global Options
 

package/docs/content/docs/sdk/discordbot.mdx

@@ -76,9 +76,10 @@ const sameId = await client.resolveChannel(guildId, '1234567890123456789')
 // Send a message to a channel
 const msg = await client.sendMessage(channelId, 'Hello world')
 
-// Send a message in a thread
+// Send a message into a thread. The request is posted to the thread itself,
+// so the returned channel_id is the thread ID, not channelId.
 const reply = await client.sendMessage(channelId, 'Reply', { thread_id: threadId })
-// → DiscordMessage { id, channel_id, author, content, timestamp }
+// → DiscordMessage { id, channel_id: threadId, author, content, timestamp, attachments? }
 
 // Reply to a specific message
 const replyToMsg = await client.sendMessage(channelId, 'On it!', { reply_to: messageId })
@@ -101,6 +102,30 @@ const edited = await client.editMessage(channelId, messageId, 'Updated content')
 await client.deleteMessage(channelId, messageId)
 ```
 
+#### createMessage
+
+`createMessage` is the single entry point behind `sendMessage` and `uploadFile`. It takes text, files, a reply target, and a thread in one call and returns the created `DiscordMessage`, including its `attachments`.
+
+```typescript
+const created = await client.createMessage(channelId, {
+  content: 'Build artifacts attached',
+  files: [{ path: '/tmp/report.pdf' }, { path: '/tmp/log.txt', filename: 'build-log.txt' }],
+  reply_to: messageId,
+  thread_id: threadId,
+})
+// → DiscordMessage { id, channel_id: threadId, content, attachments: DiscordFile[], ... }
+```
+
+How the request is built:
+
+- With no `files`, the message is sent as a plain JSON body (`content`, `message_reference`).
+- With `files`, the client sends `multipart/form-data`: a `payload_json` part carrying `content`, `message_reference`, and an `attachments` list, plus one `files[n]` part per file. Files are read from disk with `node:fs/promises`.
+- `thread_id` changes the target path to `/channels/{thread_id}/messages`. Discord's Create Message body has no thread field, so this is the only way a message lands in a thread. Posting to an archived thread by ID unarchives it unless the thread is locked.
+- `reply_to` becomes `message_reference: { message_id }`.
+- `filename` overrides the name Discord shows for that file. It's taken as a basename, so it can't contain `/` or `\`, and it can't be empty, `.`, or `..`.
+
+Validation happens before any request goes out. An empty `content` with no files throws `empty_message`, more than 10 files throws `too_many_files`, and a bad `filename` throws `invalid_filename`. Discord enforces the per-file size limit server-side; when an upload exceeds it, the client surfaces Discord error `40005` (or HTTP 413) with a message that explains the cause.
+
 ### Reactions
 
 ```typescript
@@ -131,11 +156,34 @@ const user = await client.getUser(userId)
 const file = await client.uploadFile(channelId, '/path/to/report.pdf')
 // → DiscordFile { id, filename, size, url, content_type?, height?, width? }
 
-// List file attachments from recent messages in a channel
+// Optional third parameter: caption, display name, reply target, thread
+const inThread = await client.uploadFile(channelId, '/path/to/report.pdf', {
+  content: 'Weekly report',
+  filename: 'report-2026-09.pdf',
+  reply_to: messageId,
+  thread_id: threadId,
+})
+// → DiscordFile (the first attachment of the created message)
+
+// Several files in one message: use createMessage and read the attachments back
+const batch = await client.createMessage(channelId, {
+  content: 'Screenshots',
+  files: [{ path: '/tmp/a.png' }, { path: '/tmp/b.png' }, { path: '/tmp/c.png' }],
+})
+// → batch.attachments: DiscordFile[] (up to 10 per message)
+
+// List file attachments from recent messages in a channel (one page, latest 100 messages)
 const files = await client.listFiles(channelId)
 // → DiscordFile[]
+
+// Look up one attachment by ID; pages back with before cursors and stops at the first match
+const found = await client.findFile(channelId, fileId)
+// → DiscordFile | undefined
 ```
 
+`listFiles` always makes exactly one request. `findFile` scans up to 10 pages (the latest 1,000 messages) and
+returns `undefined` when the attachment is not in that range.
+
 ### Threads
 
 ```typescript
@@ -151,8 +199,25 @@ const configured = await client.createThread(channelId, 'Design Review', {
 await client.archiveThread(threadId)
 await client.archiveThread(threadId, false) // unarchive
 // → DiscordChannel
+
+// List active threads in a server, optionally narrowed to one parent channel
+const active = await client.listThreads(guildId)
+const inChannel = await client.listThreads(guildId, { parentId: channelId })
+// → DiscordThreadListResult { threads: DiscordChannel[] }
+
+// List archived public threads of a channel (one page of up to 100)
+const archived = await client.listThreads(guildId, { parentId: channelId, archived: true })
+// → DiscordThreadListResult { threads, has_more? }
+
+// Resolve a thread name (or ID) to a thread ID
+const resolvedId = await client.resolveThread(guildId, channelId, 'bug-report-login')
+const sameThreadId = await client.resolveThread(guildId, channelId, '1234567890123456789')
 ```
 
+`listThreads` with `archived: true` needs `parentId`; without it the call throws `parent_required`. Active threads come from a single guild-wide request and are filtered by `parent_id` on the client.
+
+`resolveThread` returns a numeric ID as-is without any lookup. A name (with or without a leading `#`) is matched against the active threads of that parent channel in one request. Two or more matches throw `thread_ambiguous` with the candidate IDs in the message; no match throws `thread_not_found`. Archived threads aren't searched by name. Find them with `listThreads(..., { archived: true })` and target them by ID.
+
 ## Real-Time Events
 
 `DiscordBotListener` connects to Discord's [Gateway WebSocket](https://discord.com/developers/docs/topics/gateway) for instant event streaming — messages, reactions, slash command interactions, member changes, and more. No webhook server required.
@@ -285,11 +350,13 @@ await manager.setCurrentServer('1234567890123456789', 'My Server')
 
 ```typescript
 import type {
+  DiscordAttachmentInput,
   DiscordBotConfig,
   DiscordBotCredentials,
   DiscordBotEntry,
   DiscordBotListenerEventMap,
   DiscordChannel,
+  DiscordCreateMessageOptions,
   DiscordFile,
   DiscordGatewayChannelEvent,
   DiscordGatewayEvent,
@@ -306,10 +373,34 @@ import type {
   DiscordGuild,
   DiscordMessage,
   DiscordReaction,
+  DiscordThreadListResult,
   DiscordUser,
 } from 'agent-messenger/discordbot'
 ```
 
+Shapes used by `createMessage` and the thread helpers:
+
+```typescript
+interface DiscordAttachmentInput {
+  path: string // local file path
+  filename?: string // display name override (basename only)
+}
+
+interface DiscordCreateMessageOptions {
+  content?: string
+  files?: DiscordAttachmentInput[] // at most 10
+  reply_to?: string // message ID to reply to
+  thread_id?: string // post into this thread instead of the channel
+}
+
+interface DiscordThreadListResult {
+  threads: DiscordChannel[]
+  has_more?: boolean // only set for archived listings
+}
+```
+
+`DiscordMessage` also carries optional `attachments` (`DiscordFile[]`), `reactions` (`DiscordReaction[]`), and `thread` (`DiscordChannel`, the thread started from that message). `DiscordReaction.me` reports whether the bot itself reacted. `DiscordMessageSchema` and `DiscordReactionSchema` validate these fields too.
+
 ### Zod Schemas
 
 Runtime-validated schemas for parsing API responses:
@@ -375,7 +466,14 @@ Error codes thrown by the client:
 - `rate_limited` — Discord 429 response; the client retries automatically with `Retry-After`, then surfaces this if retries are exhausted
 - `network_error` — Fetch failed (DNS, connection refused, timeout)
 - `channel_not_found` — `resolveChannel()` could not find the named channel in the current guild
+- `empty_message` — `createMessage()` called with no content and no files
+- `too_many_files` — `createMessage()` called with more than 10 files
+- `invalid_filename` — A `filename` override was empty, `.`, `..`, or contained a path separator
+- `parent_required` — `listThreads()` called with `archived: true` but no `parentId`
+- `thread_ambiguous` — `resolveThread()` matched more than one active thread with that name; the message lists the IDs
+- `thread_not_found` — `resolveThread()` found no active thread with that name in the parent channel
 - `no_attachments` — File upload returned 200 but the response had no attachments
+- `40005` / `http_413` — Discord rejected an upload as too large for the server's limit; the message says so explicitly
 - `http_<status>` — Discord returned an unexpected status (e.g., `http_500`) without a structured `code` in the error body
 - Discord API error codes (numeric, as strings) — When Discord's response body includes a `code` field (e.g., `"50001"` for "Missing Access"), it is propagated as-is. See the [Discord JSON Error Codes reference](https://discord.com/developers/docs/topics/opcodes-and-status-codes#json-json-error-codes).
 

package/e2e/README.md

@@ -231,7 +231,9 @@ When triggering manually, you can select which platform to test:
 | `message`     | send, list, get, edit, delete, thread, replies |
 | `channel`     | list, info                                       |
 | `user`        | list, info                                       |
-| `reaction`    | add, remove                                      |
+| `file`        | upload, list, info                               |
+| `thread`      | create, list, archive                            |
+| `reaction`    | add, list, remove                                |
 | `server`      | list, current                                    |
 
 ### Webex Tests

package/e2e/config.ts

@@ -80,7 +80,7 @@ export async function validateDiscordEnvironment() {
 export const DISCORDBOT_TEST_SERVER_ID = process.env.E2E_DISCORDBOT_SERVER_ID || '1467039439770357844'
 export const DISCORDBOT_TEST_SERVER_NAME = process.env.E2E_DISCORDBOT_SERVER_NAME || 'Agent Messenger'
 export const DISCORDBOT_TEST_CHANNEL_ID = process.env.E2E_DISCORDBOT_CHANNEL_ID || '1467062262996144162'
-export const DISCORDBOT_TEST_CHANNEL = 'e2e-test'
+export const DISCORDBOT_TEST_CHANNEL = process.env.E2E_DISCORDBOT_CHANNEL_NAME || 'e2e-test'
 
 export async function validateDiscordBotEnvironment() {
   const { runCLI, parseJSON } = await import('./helpers')

package/e2e/discordbot.e2e.test.ts

@@ -1,4 +1,7 @@
 import { describe, it, expect, beforeAll, afterEach } from 'bun:test'
+import { rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 import { DiscordBotClient } from '../src/platforms/discordbot/client'
 import { DiscordBotCredentialManager } from '../src/platforms/discordbot/credential-manager'
@@ -16,6 +19,7 @@ interface TrackedMessage {
 }
 
 let testMessages: TrackedMessage[] = []
+let testThreads: string[] = []
 let cleanupClient: DiscordBotClient
 
 async function getClient(): Promise<DiscordBotClient> {
@@ -36,10 +40,29 @@ async function cleanupBotMessages(messages: TrackedMessage[]) {
   }
 }
 
+async function cleanupBotThreads(threads: string[]) {
+  for (const threadId of threads) {
+    try {
+      await cleanupClient.archiveThread(threadId)
+      await waitForRateLimit(500)
+    } catch {
+      // best-effort cleanup
+    }
+  }
+}
+
 function trackMessage(id: string, channelId: string = DISCORDBOT_TEST_CHANNEL_ID) {
   testMessages.push({ id, channelId })
 }
 
+function trackThread(id: string) {
+  testThreads.push(id)
+}
+
+function untrackThread(id: string) {
+  testThreads = testThreads.filter((threadId) => threadId !== id)
+}
+
 describe('DiscordBot E2E Tests', () => {
   beforeAll(async () => {
     await validateDiscordBotEnvironment()
@@ -51,6 +74,10 @@ describe('DiscordBot E2E Tests', () => {
       await cleanupBotMessages(testMessages)
       testMessages = []
     }
+    if (testThreads.length > 0) {
+      await cleanupBotThreads(testThreads)
+      testThreads = []
+    }
     await waitForRateLimit()
   })
 
@@ -161,12 +188,20 @@ describe('DiscordBot E2E Tests', () => {
       expect(result.exitCode).toBe(0)
     })
 
-    it('message send with --thread creates reply', async () => {
+    it('message send with --thread creates reply in the thread', async () => {
       const testId = generateTestId()
-      const sendResult = await runCLI('discordbot', ['message', 'send', DISCORDBOT_TEST_CHANNEL_ID, `Parent ${testId}`])
-      const parent = parseJSON<{ id: string }>(sendResult.stdout)
-      expect(parent?.id).toBeTruthy()
-      if (parent?.id) trackMessage(parent.id)
+      const threadResult = await runCLI('discordbot', [
+        'thread',
+        'create',
+        DISCORDBOT_TEST_CHANNEL_ID,
+        `E2E Thread ${testId}`,
+      ])
+      expect(threadResult.exitCode).toBe(0)
+
+      const thread = parseJSON<{ thread: { id: string } }>(threadResult.stdout)
+      expect(thread?.thread?.id).toBeTruthy()
+      const threadId = thread!.thread.id
+      trackThread(threadId)
 
       await waitForRateLimit()
 
@@ -176,15 +211,14 @@ describe('DiscordBot E2E Tests', () => {
         DISCORDBOT_TEST_CHANNEL_ID,
         `Reply ${testId}`,
         '--thread',
-        parent!.id,
+        threadId,
       ])
       expect(replyResult.exitCode).toBe(0)
 
-      const reply = parseJSON<{ id: string; thread_id: string }>(replyResult.stdout)
+      const reply = parseJSON<{ id: string; channel_id: string }>(replyResult.stdout)
       expect(reply?.id).toBeTruthy()
-
-      const replyChannel = reply?.thread_id || DISCORDBOT_TEST_CHANNEL_ID
-      if (reply?.id) trackMessage(reply.id, replyChannel)
+      expect(reply?.channel_id).toBe(threadId)
+      if (reply?.id) trackMessage(reply.id, threadId)
     }, 30000)
 
     it('message replies gets thread messages', async () => {
@@ -201,6 +235,7 @@ describe('DiscordBot E2E Tests', () => {
       const thread = parseJSON<{ thread: { id: string } }>(threadResult.stdout)
       expect(thread?.thread?.id).toBeTruthy()
       const threadId = thread!.thread.id
+      trackThread(threadId)
 
       await waitForRateLimit()
 
@@ -222,9 +257,155 @@ describe('DiscordBot E2E Tests', () => {
 
       // cleanup: archive the thread
       await runCLI('discordbot', ['thread', 'archive', threadId])
+      untrackThread(threadId)
     })
   })
 
+  describe('file', () => {
+    it('uploads a file into a thread and round-trips its metadata', async () => {
+      const testId = generateTestId()
+      const filePath = join(tmpdir(), `e2e-${testId}.txt`)
+      await Bun.write(filePath, testId)
+
+      try {
+        const threadResult = await runCLI('discordbot', [
+          'thread',
+          'create',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          `E2E Thread ${testId}`,
+        ])
+        expect(threadResult.exitCode).toBe(0)
+        const thread = parseJSON<{ thread: { id: string } }>(threadResult.stdout)
+        expect(thread?.thread?.id).toBeTruthy()
+        const threadId = thread!.thread.id
+        trackThread(threadId)
+
+        await waitForRateLimit()
+
+        const uploadResult = await runCLI('discordbot', [
+          'file',
+          'upload',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          filePath,
+          '--text',
+          `File ${testId}`,
+          '--thread',
+          threadId,
+        ])
+        expect(uploadResult.exitCode).toBe(0)
+        const upload = parseJSON<{
+          channel_id: string
+          message_id: string
+          file: { id: string; filename: string }
+          files: Array<{ filename: string }>
+        }>(uploadResult.stdout)
+        expect(upload?.channel_id).toBe(threadId)
+        expect(upload?.message_id).toBeTruthy()
+        expect(upload?.file?.filename).toBe(`e2e-${testId}.txt`)
+        expect(upload?.files).toHaveLength(1)
+        trackMessage(upload!.message_id, threadId)
+
+        await waitForRateLimit()
+
+        const messageResult = await runCLI('discordbot', ['message', 'get', threadId, upload!.message_id])
+        expect(messageResult.exitCode).toBe(0)
+        const message = parseJSON<{
+          channel_id: string
+          content: string
+          attachments: Array<{ id: string; filename: string; size: number }>
+        }>(messageResult.stdout)
+        expect(message?.channel_id).toBe(threadId)
+        expect(message?.content).toBe(`File ${testId}`)
+        expect(message?.attachments).toHaveLength(1)
+        expect(message!.attachments[0].filename).toBe(`e2e-${testId}.txt`)
+        expect(message!.attachments[0].size).toBe(Buffer.byteLength(testId))
+
+        await waitForRateLimit()
+
+        const namedResult = await runCLI('discordbot', [
+          'message',
+          'send',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          `Reply ${testId}`,
+          '--thread',
+          `E2E Thread ${testId}`,
+        ])
+        expect(namedResult.exitCode).toBe(0)
+        const named = parseJSON<{ id: string; channel_id: string }>(namedResult.stdout)
+        expect(named?.channel_id).toBe(threadId)
+        if (named?.id) trackMessage(named.id, threadId)
+
+        await waitForRateLimit()
+
+        const missingNameResult = await runCLI('discordbot', [
+          'message',
+          'send',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          'x',
+          '--thread',
+          `no-such-thread-${testId}`,
+        ])
+        expect(missingNameResult.exitCode).toBe(1)
+        const missingName = parseJSON<{ error: string }>(missingNameResult.stdout)
+        expect(missingName?.error).toContain('thread list')
+        expect(missingNameResult.stderr).toBe('')
+
+        await waitForRateLimit()
+
+        const activeListResult = await runCLI('discordbot', ['thread', 'list', DISCORDBOT_TEST_CHANNEL_ID])
+        expect(activeListResult.exitCode).toBe(0)
+        const activeList = parseJSON<{
+          threads: Array<{ id: string; parent_id?: string; archived?: boolean }>
+        }>(activeListResult.stdout)
+        expect(
+          activeList?.threads?.some(
+            (item) => item.id === threadId && item.parent_id === DISCORDBOT_TEST_CHANNEL_ID && item.archived === false,
+          ),
+        ).toBe(true)
+
+        await waitForRateLimit()
+
+        const infoResult = await runCLI('discordbot', ['file', 'info', threadId, upload!.file.id])
+        expect(infoResult.exitCode).toBe(0)
+        const info = parseJSON<{ id: string; filename: string }>(infoResult.stdout)
+        expect(info?.id).toBe(upload!.file.id)
+        expect(info?.filename).toBe(`e2e-${testId}.txt`)
+
+        const missingInfoResult = await runCLI('discordbot', [
+          'file',
+          'info',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          '000000000000000000',
+        ])
+        expect(missingInfoResult.exitCode).toBe(0)
+        const missingInfo = parseJSON<{ error: string }>(missingInfoResult.stdout)
+        expect(missingInfo?.error).toContain('File not found')
+
+        await waitForRateLimit()
+
+        const parentMessagesResult = await runCLI('discordbot', [
+          'message',
+          'list',
+          DISCORDBOT_TEST_CHANNEL_ID,
+          '--limit',
+          '5',
+        ])
+        expect(parentMessagesResult.exitCode).toBe(0)
+        const parentMessages = parseJSON<{ messages: Array<{ content: string }> }>(parentMessagesResult.stdout)
+        expect(parentMessages?.messages?.some((item) => item.content === 'x')).toBe(false)
+
+        const archiveResult = await runCLI('discordbot', ['thread', 'archive', threadId])
+        expect(archiveResult.exitCode).toBe(0)
+        untrackThread(threadId)
+
+        // Discord's archived-thread index is eventually consistent; active listing above is the stable proof.
+        await waitForRateLimit(2000)
+      } finally {
+        await rm(filePath, { force: true })
+      }
+    }, 60000)
+  })
+
   describe('channel', () => {
     it('channel list returns channels array', async () => {
       const result = await runCLI('discordbot', ['channel', 'list'])
@@ -288,6 +469,11 @@ describe('DiscordBot E2E Tests', () => {
 
       await waitForRateLimit(2000)
 
+      const emptyListResult = await runCLI('discordbot', ['reaction', 'list', DISCORDBOT_TEST_CHANNEL_ID, sent!.id])
+      expect(emptyListResult.exitCode).toBe(0)
+      const emptyList = parseJSON<{ reactions: unknown[] }>(emptyListResult.stdout)
+      expect(emptyList?.reactions).toEqual([])
+
       // when: add reaction
       const addResult = await runCLI('discordbot', ['reaction', 'add', DISCORDBOT_TEST_CHANNEL_ID, sent!.id, '👍'])
       expect(addResult.exitCode).toBe(0)
@@ -297,6 +483,15 @@ describe('DiscordBot E2E Tests', () => {
 
       await waitForRateLimit(2000)
 
+      const listResult = await runCLI('discordbot', ['reaction', 'list', DISCORDBOT_TEST_CHANNEL_ID, sent!.id])
+      expect(listResult.exitCode).toBe(0)
+      const listed = parseJSON<{
+        reactions: Array<{ emoji: { name: string }; count: number; me: boolean }>
+      }>(listResult.stdout)
+      expect(listed?.reactions?.[0]?.emoji?.name).toBe('👍')
+      expect(listed?.reactions?.[0]?.count).toBe(1)
+      expect(listed?.reactions?.[0]?.me).toBe(true)
+
       // then: remove reaction
       const removeResult = await runCLI('discordbot', [
         'reaction',
@@ -309,7 +504,7 @@ describe('DiscordBot E2E Tests', () => {
 
       const removeData = parseJSON<{ success: boolean }>(removeResult.stdout)
       expect(removeData?.success).toBe(true)
-    }, 15000)
+    }, 30000)
   })
 
   describe('server', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-messenger",
-  "version": "2.38.1",
+  "version": "2.39.0",
   "description": "Multi-platform messaging CLI for AI agents (Slack, Discord, Teams, Webex, Telegram, Telegram Bot, WhatsApp, LINE, iMessage, Instagram, KakaoTalk, Channel Talk)",
   "repository": {
     "type": "git",

package/skills/agent-channeltalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalk
 description: Interact with Channel Talk using extracted desktop app or browser credentials - read chats, send messages, search messages, manage groups
-version: 2.38.1
+version: 2.39.0
 allowed-tools: Bash(agent-channeltalk:*)
 metadata:
   openclaw:

package/skills/agent-channeltalkbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalkbot
 description: Interact with Channel Talk workspaces using API credentials - send messages, read chats, manage groups and bots
-version: 2.38.1
+version: 2.39.0
 allowed-tools: Bash(agent-channeltalkbot:*)
 metadata:
   openclaw: