agent-messenger 2.38.0 → 2.39.0

package/skills/agent-slack/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slack
 description: Interact with Slack workspaces - send messages, read channels, manage reactions
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-slack:*)
 metadata:
   openclaw:
@@ -74,8 +74,14 @@ agent-slack workspace remove <workspace-id>
 
 # Check auth status
 agent-slack auth status
+
+# Run one command against another workspace without switching
+agent-slack --workspace <workspace-id> channel list
+agent-slack --workspace <workspace-id> auth status
 ```
 
+The global `--workspace <id>` flag goes before the command and applies to every command that uses a stored workspace, including `auth status` and `auth logout`. It targets that workspace for this one invocation only and does not change the current workspace. If the id is not stored, `auth status` fails with `Workspace not found: <id>`. `auth extract` and `auth qr` discover workspaces instead of targeting one, so the flag does not affect them; they set the current workspace only when none is set yet.
+
 ## Memory
 
 The agent maintains a `~/.config/agent-messenger/MEMORY.md` file as persistent memory across sessions. This is agent-managed — the CLI does not read or write this file. Use the `Read` and `Write` tools to manage your memory file.
@@ -171,9 +177,10 @@ agent-slack auth qr --debug   # show each redirect hop for troubleshooting
 # Check auth status
 agent-slack auth status
 
-# Logout from a workspace (defaults to current)
+# Logout from a workspace (defaults to the --workspace selection, then current)
 agent-slack auth logout
 agent-slack auth logout <workspace-id>
+agent-slack --workspace <workspace-id> auth logout
 ```
 
 ### Whoami Command

package/skills/agent-slack/references/authentication.md

@@ -152,6 +152,18 @@ agent-slack workspace switch T789012
 
 All subsequent commands will use the selected workspace until you switch again.
 
+### Use a Workspace for One Command
+
+Pass the global `--workspace <id>` flag before the command to target another workspace for a single invocation without switching:
+
+```bash
+agent-slack --workspace T789012 channel list
+agent-slack --workspace T789012 auth status
+agent-slack --workspace T789012 auth logout
+```
+
+The flag applies to every command that uses a stored workspace, including `auth status` and `auth logout`, and does not change `current_workspace`. `auth extract` and `auth qr` discover workspaces instead of targeting one, so the flag does not affect them; they set `current_workspace` only when none is set yet. `auth logout` removes the selected workspace when no positional id is given (a positional id still wins), and `auth status` fails with `Workspace not found: <id>` if the selected id is not stored.
+
 ### Current Workspace
 
 Check which workspace is active:

package/skills/agent-slack/references/common-patterns.md

@@ -612,6 +612,24 @@ agent-slack reminder complete Rm001
 agent-slack reminder delete Rm002
 ```
 
+## Pattern: Work Across Workspaces
+
+**Use case**: Read or act in a second workspace without changing the current one
+
+```bash
+#!/bin/bash
+
+# The global --workspace flag targets one workspace for a single command
+agent-slack --workspace T789012 auth status
+agent-slack --workspace T789012 channel list
+agent-slack --workspace T789012 message send general "Cross-workspace update"
+
+# The current workspace is unchanged afterwards
+agent-slack workspace current
+```
+
+**When to use**: Occasional commands in another workspace. Use `workspace switch` only when the default should change for every later command.
+
 ## See Also
 
 - [Authentication Guide](authentication.md) - Setting up credentials

package/skills/agent-slackbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slackbot
 description: Interact with Slack workspaces using bot tokens - send messages, read channels, manage reactions
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:

package/skills/agent-teams/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-teams
 description: Interact with Microsoft Teams - send messages, read channels, manage reactions
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw:

package/skills/agent-telegram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegram
 description: Interact with Telegram through TDLib - authenticate, inspect chats, and send messages
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-telegram:*)
 ---
 

package/skills/agent-telegrambot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegrambot
 description: Interact with Telegram using bot tokens - send messages, read chats, manage reactions
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-telegrambot:*)
 metadata:
   openclaw:

package/skills/agent-webex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webex
 description: Interact with Cisco Webex - send messages, read spaces, manage memberships
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:

package/skills/agent-webexbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webexbot
 description: Interact with Cisco Webex using bot tokens - send messages, reply in threads, upload and download files, look up people, read spaces, manage memberships, stream real-time events
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-webexbot:*)
 metadata:
   openclaw:

package/skills/agent-wechatbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-wechatbot
 description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-wechatbot:*)
 metadata:
   openclaw:

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.38.0
+version: 2.39.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

package/src/platforms/discordbot/client-message.ts

@@ -0,0 +1,91 @@
+import { readFile } from 'node:fs/promises'
+
+import type { DiscordCreateMessageOptions, DiscordFile, DiscordMessage } from './types'
+import { DiscordBotError } from './types'
+
+type Request = <T>(method: string, path: string, body?: unknown) => Promise<T>
+type RequestFormData = <T>(path: string, formData: FormData) => Promise<T>
+
+const MESSAGE_PAGE_LIMIT = 100
+export const FILE_LOOKUP_MAX_PAGES = 10
+
+export async function createMessage(
+  request: Request,
+  requestFormData: RequestFormData,
+  channelId: string,
+  options: DiscordCreateMessageOptions,
+): Promise<DiscordMessage> {
+  const files = options.files ?? []
+  if ((options.content === undefined || options.content.trim() === '') && files.length === 0) {
+    throw new DiscordBotError('Message must have content or at least one file', 'empty_message')
+  }
+  if (files.length > 10) {
+    throw new DiscordBotError('Discord allows at most 10 files per message', 'too_many_files')
+  }
+
+  const partNames = files.map((file) => {
+    if (
+      file.filename !== undefined &&
+      (file.filename === '' || file.filename === '.' || file.filename === '..' || /[\\/]/.test(file.filename))
+    ) {
+      throw new DiscordBotError('Invalid filename', 'invalid_filename')
+    }
+    return (file.filename ?? file.path).replaceAll('\\', '/').split('/').pop() || 'file'
+  })
+  const target = options.thread_id ?? channelId
+  const payload: Record<string, unknown> = {}
+
+  if (options.content !== undefined) payload.content = options.content
+  if (options.reply_to !== undefined) payload.message_reference = { message_id: options.reply_to }
+
+  if (files.length === 0) return request<DiscordMessage>('POST', `/channels/${target}/messages`, payload)
+
+  const formData = new FormData()
+  formData.append(
+    'payload_json',
+    JSON.stringify({ ...payload, attachments: files.map((_, index) => ({ id: index, filename: partNames[index] })) }),
+  )
+  for (const [index, file] of files.entries()) {
+    formData.append(`files[${index}]`, new Blob([await readFile(file.path)]), partNames[index])
+  }
+  return requestFormData<DiscordMessage>(`/channels/${target}/messages`, formData)
+}
+
+export async function uploadFile(
+  create: (channelId: string, options: DiscordCreateMessageOptions) => Promise<DiscordMessage>,
+  channelId: string,
+  filePath: string,
+  options?: { content?: string; filename?: string; reply_to?: string; thread_id?: string },
+): Promise<DiscordFile> {
+  const message = await create(channelId, {
+    content: options?.content,
+    files: [{ path: filePath, filename: options?.filename }],
+    reply_to: options?.reply_to,
+    thread_id: options?.thread_id,
+  })
+  const first = message.attachments?.[0]
+  if (!first) throw new DiscordBotError('Upload succeeded but no attachments returned', 'no_attachments')
+  return first
+}
+
+export async function listFiles(request: Request, channelId: string): Promise<DiscordFile[]> {
+  const messages = await request<DiscordMessage[]>('GET', `/channels/${channelId}/messages?limit=${MESSAGE_PAGE_LIMIT}`)
+  return messages.flatMap((message) => message.attachments ?? [])
+}
+
+export async function findFile(request: Request, channelId: string, fileId: string): Promise<DiscordFile | undefined> {
+  let before: string | undefined
+  for (let page = 0; page < FILE_LOOKUP_MAX_PAGES; page += 1) {
+    const query = before
+      ? `?limit=${MESSAGE_PAGE_LIMIT}&before=${encodeURIComponent(before)}`
+      : `?limit=${MESSAGE_PAGE_LIMIT}`
+    const messages = await request<DiscordMessage[]>('GET', `/channels/${channelId}/messages${query}`)
+    const found = messages.flatMap((message) => message.attachments ?? []).find((file) => file.id === fileId)
+    if (found) return found
+    if (messages.length < MESSAGE_PAGE_LIMIT) return undefined
+    const oldest = messages[messages.length - 1]?.id
+    if (!oldest || oldest === before) return undefined
+    before = oldest
+  }
+  return undefined
+}

package/src/platforms/discordbot/client-threads.test.ts

@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+
+import { DiscordBotClient } from './client'
+import { listThreads, resolveThread } from './client-threads'
+import type { DiscordChannel } from './types'
+
+interface FetchCall {
+  url: string
+  options?: RequestInit
+}
+
+describe('Discord thread client helpers', () => {
+  const originalFetch = globalThis.fetch
+  let fetchCalls: FetchCall[] = []
+  let fetchResponses: Response[] = []
+  let fetchIndex = 0
+
+  beforeEach(() => {
+    fetchCalls = []
+    fetchResponses = []
+    fetchIndex = 0
+    ;(globalThis as Record<string, unknown>).fetch = async (
+      url: string | URL | Request,
+      options?: RequestInit,
+    ): Promise<Response> => {
+      fetchCalls.push({ url: url.toString(), options })
+      const response = fetchResponses[fetchIndex]
+      fetchIndex++
+      if (!response) {
+        throw new Error('No mock response configured')
+      }
+      return response
+    }
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  const mockResponse = (body: unknown, status = 200) => {
+    fetchResponses.push(
+      new Response(body === null ? null : JSON.stringify(body), {
+        status,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-RateLimit-Remaining': '10',
+          'X-RateLimit-Reset': String(Date.now() / 1000 + 60),
+          'X-RateLimit-Bucket': 'test-bucket',
+        },
+      }),
+    )
+  }
+
+  const fetchTransport = {
+    request: async <T>(method: string, path: string): Promise<T> => {
+      const response = await fetch(`https://discord.com/api/v10${path}`, { method })
+      return response.json() as Promise<T>
+    },
+  }
+
+  const thread = (id: string, name: string, parentId: string): DiscordChannel => ({
+    id,
+    guild_id: 'guild1',
+    name,
+    type: 11,
+    parent_id: parentId,
+  })
+
+  it('numeric passthrough makes zero fetch calls', async () => {
+    await expect(resolveThread(fetchTransport, 'guild1', 'parent1', '123')).resolves.toBe('123')
+    expect(fetchCalls).toHaveLength(0)
+  })
+
+  it('numeric-looking names are treated as ids', async () => {
+    await expect(resolveThread(fetchTransport, 'guild1', 'parent1', '123')).resolves.toBe('123')
+    expect(fetchCalls).toHaveLength(0)
+  })
+
+  it('resolves a name from active threads filtered by parent', async () => {
+    mockResponse({ threads: [thread('thread1', 'ops', 'parent1'), thread('thread2', 'other', 'parent1')], members: [] })
+
+    await expect(resolveThread(fetchTransport, 'guild1', 'parent1', 'ops')).resolves.toBe('thread1')
+    expect(fetchCalls).toHaveLength(1)
+    expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/guild1/threads/active')
+  })
+
+  it('strips a leading hash when resolving a name', async () => {
+    mockResponse({ threads: [thread('thread1', 'ops', 'parent1')], members: [] })
+
+    await expect(resolveThread(fetchTransport, 'guild1', 'parent1', '#ops')).resolves.toBe('thread1')
+  })
+
+  it('ignores a same-named thread under a different parent', async () => {
+    mockResponse({ threads: [thread('thread2', 'ops', 'parent2')], members: [] })
+
+    const error = await resolveThread(fetchTransport, 'guild1', 'parent1', 'ops').catch((caught) => caught)
+    expect(error.code).toBe('thread_not_found')
+  })
+
+  it('rejects two same-named active threads under one parent as ambiguous', async () => {
+    mockResponse({ threads: [thread('thread1', 'ops', 'parent1'), thread('thread2', 'ops', 'parent1')], members: [] })
+
+    const error = await resolveThread(fetchTransport, 'guild1', 'parent1', 'ops').catch((caught) => caught)
+    expect(error.code).toBe('thread_ambiguous')
+    expect(error.message).toContain('thread1')
+    expect(error.message).toContain('thread2')
+  })
+
+  it('does not resolve archived-only names', async () => {
+    mockResponse({ threads: [], members: [] })
+
+    const error = await resolveThread(fetchTransport, 'guild1', 'parent1', 'old').catch((caught) => caught)
+    expect(error.code).toBe('thread_not_found')
+    expect(error.message).toContain('--archived')
+    expect(fetchCalls).toHaveLength(1)
+    expect(fetchCalls[0].url).not.toContain('/threads/archived/')
+  })
+
+  it('names the missing thread in the not-found error', async () => {
+    mockResponse({ threads: [], members: [] })
+
+    const error = await resolveThread(fetchTransport, 'guild1', 'parent1', 'missing').catch((caught) => caught)
+    expect(error.code).toBe('thread_not_found')
+    expect(error.message).toContain('Thread not found: "missing"')
+  })
+
+  it('requires a parent for archived thread listing', async () => {
+    const error = await listThreads(fetchTransport, 'guild1', { archived: true }).catch((caught) => caught)
+    expect(error.code).toBe('parent_required')
+    expect(fetchCalls).toHaveLength(0)
+  })
+
+  it('lists archived public threads for a parent and returns has_more', async () => {
+    const archived = thread('thread1', 'old', 'parent1')
+    mockResponse({ threads: [archived], members: [], has_more: true })
+
+    await expect(listThreads(fetchTransport, 'guild1', { parentId: 'parent1', archived: true })).resolves.toEqual({
+      threads: [archived],
+      has_more: true,
+    })
+    expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/parent1/threads/archived/public?limit=100')
+  })
+
+  it('lists all active threads by default', async () => {
+    const threads = [thread('thread1', 'ops', 'parent1'), thread('thread2', 'other', 'parent2')]
+    mockResponse({ threads, members: [] })
+
+    await expect(listThreads(fetchTransport, 'guild1')).resolves.toEqual({ threads })
+    expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/guild1/threads/active')
+  })
+
+  it('filters active threads by parent', async () => {
+    const matching = thread('thread1', 'ops', 'parent1')
+    mockResponse({ threads: [matching, thread('thread2', 'other', 'parent2')], members: [] })
+
+    await expect(listThreads(fetchTransport, 'guild1', { parentId: 'parent1' })).resolves.toEqual({
+      threads: [matching],
+    })
+  })
+
+  it('delegates listThreads through the client', async () => {
+    const threads = [thread('thread1', 'ops', 'parent1')]
+    mockResponse({ threads, members: [] })
+    const client = await new DiscordBotClient().login({ token: 'bot-token' })
+
+    await expect(client.listThreads('guild1', { parentId: 'parent1' })).resolves.toEqual({ threads })
+    expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/guild1/threads/active')
+  })
+
+  it('delegates resolveThread through the client', async () => {
+    mockResponse({ threads: [thread('thread1', 'ops', 'parent1')], members: [] })
+    const client = await new DiscordBotClient().login({ token: 'bot-token' })
+
+    await expect(client.resolveThread('guild1', 'parent1', 'ops')).resolves.toBe('thread1')
+    expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/guild1/threads/active')
+  })
+})

package/src/platforms/discordbot/client-threads.ts

@@ -0,0 +1,69 @@
+import type { DiscordThreadListResult } from './types'
+import { DiscordBotError } from './types'
+
+export interface ThreadTransport {
+  request<T>(method: string, path: string, body?: unknown): Promise<T>
+}
+
+interface ThreadListResponse {
+  threads: DiscordThreadListResult['threads']
+  members: unknown[]
+  has_more?: boolean
+}
+
+export async function listThreads(
+  t: ThreadTransport,
+  guildId: string,
+  options?: { parentId?: string; archived?: boolean },
+): Promise<DiscordThreadListResult> {
+  if (options?.archived === true) {
+    if (!options.parentId) {
+      throw new DiscordBotError('thread list --archived requires a channel', 'parent_required')
+    }
+
+    const response = await t.request<ThreadListResponse>(
+      'GET',
+      `/channels/${options.parentId}/threads/archived/public?limit=100`,
+    )
+    return { threads: response.threads, has_more: response.has_more }
+  }
+
+  const response = await t.request<ThreadListResponse>('GET', `/guilds/${guildId}/threads/active`)
+  const threads = options?.parentId
+    ? response.threads.filter((thread) => thread.parent_id === options.parentId)
+    : response.threads
+  return { threads }
+}
+
+export async function resolveThread(
+  t: ThreadTransport,
+  guildId: string,
+  parentChannelId: string,
+  thread: string,
+): Promise<string> {
+  if (/^\d+$/.test(thread)) {
+    return thread
+  }
+
+  const name = thread.replace(/^#/, '')
+  const response = await t.request<ThreadListResponse>('GET', `/guilds/${guildId}/threads/active`)
+  const matches = response.threads.filter(
+    (candidate) => candidate.parent_id === parentChannelId && candidate.name === name,
+  )
+
+  if (matches.length === 1) {
+    return matches[0].id
+  }
+
+  if (matches.length > 1) {
+    throw new DiscordBotError(
+      `Ambiguous thread "${name}" in this channel: ${matches.map((match) => match.id).join(', ')}. Use the thread ID.`,
+      'thread_ambiguous',
+    )
+  }
+
+  throw new DiscordBotError(
+    `Thread not found: "${name}". Run "thread list <channel>" (add --archived for archived threads) or use the thread ID. If <channel> is itself a thread, send to it directly without --thread.`,
+    'thread_not_found',
+  )
+}