agent-messenger 2.21.0 → 2.22.0

package/src/platforms/webexbot/commands/file.ts

@@ -0,0 +1,104 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { basename, resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface FileResult {
+  id?: string
+  roomId?: string
+  files?: string[]
+  created?: string
+  downloaded?: string
+  filename?: string
+  contentType?: string
+  size?: number
+  error?: string
+}
+
+export async function uploadAction(
+  space: string,
+  path: string,
+  options: BotOption & { text?: string; markdown?: boolean; parent?: string },
+): Promise<FileResult> {
+  try {
+    const client = await getClient(options)
+    const filePath = resolve(path)
+    const content = await readFile(filePath)
+    const message = await client.uploadFile(
+      space,
+      { content: new Blob([content]), filename: basename(filePath) },
+      { text: options.text, markdown: options.markdown, parentId: options.parent },
+    )
+
+    return {
+      id: message.id,
+      roomId: message.roomId,
+      files: message.files,
+      created: message.created,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function downloadAction(
+  contentRef: string,
+  output: string | undefined,
+  options: BotOption,
+): Promise<FileResult> {
+  try {
+    const client = await getClient(options)
+    const { data, filename, contentType } = await client.downloadContent(contentRef)
+    // When no explicit output is given, confine the server-provided name to cwd.
+    const outputPath = output ? resolve(output) : resolve(process.cwd(), basename(filename))
+    await writeFile(outputPath, Buffer.from(data))
+
+    return {
+      downloaded: outputPath,
+      filename,
+      contentType,
+      size: data.byteLength,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const fileCommand = new Command('file')
+  .description('File commands')
+  .addCommand(
+    new Command('upload')
+      .description('Upload a local file to a space')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<path>', 'Local file path')
+      .option('--text <text>', 'Optional message to send with the file')
+      .option('--markdown', 'Treat --text as markdown')
+      .option('--parent <id>', 'Reply within a thread (parent message ID)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(
+        async (
+          space: string,
+          path: string,
+          opts: BotOption & { text?: string; markdown?: boolean; parent?: string },
+        ) => {
+          cliOutput(await uploadAction(space, path, opts), opts.pretty)
+        },
+      ),
+  )
+  .addCommand(
+    new Command('download')
+      .description('Download a file attachment by content URL or ID')
+      .argument('<content>', 'File content URL (from message.files) or content ID')
+      .argument('[output]', 'Output path (defaults to original filename)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (content: string, output: string | undefined, opts: BotOption) => {
+        cliOutput(await downloadAction(content, output, opts), opts.pretty)
+      }),
+  )

package/src/platforms/webexbot/commands/index.ts

@@ -1,6 +1,9 @@
 export { authCommand } from './auth'
+export { fileCommand } from './file'
 export { listenCommand } from './listen'
 export { memberCommand } from './member'
 export { messageCommand } from './message'
+export { snapshotCommand } from './snapshot'
 export { spaceCommand } from './space'
+export { userCommand } from './user'
 export { whoamiCommand } from './whoami'

package/src/platforms/webexbot/commands/message.ts

@@ -40,11 +40,27 @@ function formatMessage(message: WebexMessage): MessageResult {
 export async function sendAction(
   space: string,
   text: string,
+  options: BotOption & { markdown?: boolean; parent?: string },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendMessage(space, text, { markdown: options.markdown, parentId: options.parent })
+
+    return formatMessage(message)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function replyAction(
+  space: string,
+  parentId: string,
+  text: string,
   options: BotOption & { markdown?: boolean },
 ): Promise<MessageResult> {
   try {
     const client = await getClient(options)
-    const message = await client.sendMessage(space, text, { markdown: options.markdown })
+    const message = await client.sendMessage(space, text, { markdown: options.markdown, parentId })
 
     return formatMessage(message)
   } catch (error) {
@@ -52,6 +68,30 @@ export async function sendAction(
   }
 }
 
+export async function repliesAction(
+  space: string,
+  parentId: string,
+  options: BotOption & { max?: string },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 50
+    const messages = await client.listReplies(space, parentId, { max })
+
+    return {
+      messages: messages.map((msg) => ({
+        id: msg.id,
+        roomId: msg.roomId,
+        text: msg.text,
+        personEmail: msg.personEmail,
+        created: msg.created,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
 export async function dmAction(
   email: string,
   text: string,
@@ -133,12 +173,38 @@ export const messageCommand = new Command('message')
       .argument('<space>', 'Space/Room ID')
       .argument('<text>', 'Message text')
       .option('--markdown', 'Send as markdown')
+      .option('--parent <id>', 'Reply within a thread (parent message ID)')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
-      .action(async (space: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+      .action(async (space: string, text: string, opts: BotOption & { markdown?: boolean; parent?: string }) => {
         cliOutput(await sendAction(space, text, opts), opts.pretty)
       }),
   )
+  .addCommand(
+    new Command('reply')
+      .description('Reply to a message in a thread')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<parent>', 'Parent message ID')
+      .argument('<text>', 'Reply text')
+      .option('--markdown', 'Send as markdown')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, parent: string, text: string, opts: BotOption & { markdown?: boolean }) => {
+        cliOutput(await replyAction(space, parent, text, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('replies')
+      .description('List replies in a thread')
+      .argument('<space>', 'Space/Room ID')
+      .argument('<parent>', 'Parent message ID')
+      .option('--max <n>', 'Number of replies to fetch', '50')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (space: string, parent: string, opts: BotOption & { max?: string }) => {
+        cliOutput(await repliesAction(space, parent, opts), opts.pretty)
+      }),
+  )
   .addCommand(
     new Command('dm')
       .description('Send a direct message by recipient email')

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

@@ -0,0 +1,60 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface SnapshotResult {
+  bot?: {
+    id: string
+    displayName: string
+    emails: string[]
+  }
+  spaces?: Array<{
+    id: string
+    title: string
+    type?: 'group' | 'direct'
+    lastActivity?: string
+  }>
+  hint?: string
+  error?: string
+}
+
+export async function snapshotAction(options: BotOption & { full?: boolean; max?: string }): Promise<SnapshotResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : 100
+
+    const [me, spaces] = await Promise.all([client.testAuth(), client.listSpaces({ max })])
+
+    const result: SnapshotResult = {
+      bot: {
+        id: me.id,
+        displayName: me.displayName,
+        emails: me.emails,
+      },
+      spaces: options.full
+        ? spaces.map((s) => ({ id: s.id, title: s.title, type: s.type, lastActivity: s.lastActivity }))
+        : spaces.map((s) => ({ id: s.id, title: s.title })),
+    }
+
+    if (!options.full) {
+      result.hint = "Use 'message list <space>' for messages, 'space info <space>' for details."
+    }
+
+    return result
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const snapshotCommand = new Command('snapshot')
+  .description('Workspace overview for AI agents (brief by default, --full for details)')
+  .option('--full', 'Include full space details')
+  .option('--max <n>', 'Number of spaces to retrieve', '100')
+  .option('--bot <id>', 'Use specific bot')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption & { full?: boolean; max?: string }) => {
+    cliOutput(await snapshotAction(opts), opts.pretty)
+  })

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

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockListPeople = mock(() =>
+  Promise.resolve([
+    {
+      id: 'p1',
+      emails: ['alice@example.com'],
+      displayName: 'Alice',
+      orgId: 'o1',
+      type: 'person' as const,
+      created: '',
+    },
+  ]),
+)
+
+const mockGetPerson = mock(() =>
+  Promise.resolve({
+    id: 'p1',
+    emails: ['alice@example.com'],
+    displayName: 'Alice',
+    orgId: 'o1',
+    type: 'person' as const,
+    created: '2024-01-01T00:00:00Z',
+  }),
+)
+
+mock.module('../client', () => ({
+  WebexBotClient: class MockWebexBotClient {
+    async login(): Promise<this> {
+      return this
+    }
+    listPeople = mockListPeople
+    getPerson = mockGetPerson
+  },
+}))
+
+import { WebexBotCredentialManager } from '../credential-manager'
+import { infoAction, listAction } from './user'
+
+describe('webexbot user commands', () => {
+  let tempDir: string
+  let manager: WebexBotCredentialManager
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `webexbot-user-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    manager = new WebexBotCredentialManager(tempDir)
+    await manager.setCredentials({ token: 'token123', bot_id: 'bot1', bot_name: 'Bot' })
+    mockListPeople.mockClear()
+    mockGetPerson.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+  })
+
+  it('lists people by email', async () => {
+    const result = await listAction({ _credManager: manager, email: 'alice@example.com' })
+
+    expect(result.users).toHaveLength(1)
+    expect(result.users?.[0].displayName).toBe('Alice')
+    expect(mockListPeople).toHaveBeenCalled()
+  })
+
+  it('gets a person by id', async () => {
+    const result = await infoAction('p1', { _credManager: manager })
+
+    expect(result.id).toBe('p1')
+    expect(result.displayName).toBe('Alice')
+  })
+})

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

@@ -0,0 +1,98 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { WebexPerson } from '../../webex/types'
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface UserResult {
+  id?: string
+  emails?: string[]
+  displayName?: string
+  nickName?: string
+  firstName?: string
+  lastName?: string
+  avatar?: string
+  orgId?: string
+  type?: 'person' | 'bot'
+  created?: string
+  users?: Array<{
+    id: string
+    emails: string[]
+    displayName: string
+    type: 'person' | 'bot'
+  }>
+  error?: string
+}
+
+function formatPerson(person: WebexPerson): UserResult {
+  return {
+    id: person.id,
+    emails: person.emails,
+    displayName: person.displayName,
+    nickName: person.nickName,
+    firstName: person.firstName,
+    lastName: person.lastName,
+    avatar: person.avatar,
+    orgId: person.orgId,
+    type: person.type,
+    created: person.created,
+  }
+}
+
+export async function listAction(
+  options: BotOption & { email?: string; displayName?: string; max?: string },
+): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const max = options.max ? parseInt(options.max, 10) : undefined
+    const people = await client.listPeople({ email: options.email, displayName: options.displayName, max })
+
+    return {
+      users: people.map((p) => ({
+        id: p.id,
+        emails: p.emails,
+        displayName: p.displayName,
+        type: p.type,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function infoAction(personId: string, options: BotOption): Promise<UserResult> {
+  try {
+    const client = await getClient(options)
+    const person = await client.getPerson(personId)
+    return formatPerson(person)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const userCommand = new Command('user')
+  .description('User commands')
+  .addCommand(
+    new Command('list')
+      .description('Search people by email or display name')
+      .option('--email <email>', 'Filter by exact email')
+      .option('--display-name <name>', 'Filter by display name prefix')
+      .option('--max <n>', 'Number of users to retrieve')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: BotOption & { email?: string; displayName?: string; max?: string }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get details for a person')
+      .argument('<id>', 'Person ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (personId: string, opts: BotOption) => {
+        cliOutput(await infoAction(personId, opts), opts.pretty)
+      }),
+  )