agent-messenger 2.21.0 → 2.23.0

package/src/platforms/webexbot/client.test.ts

@@ -0,0 +1,322 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test'
+
+import { toRestId } from '../webex/id-normalizer'
+import { WebexBotClient } from './client'
+
+describe('WebexBotClient', () => {
+  const originalFetch = globalThis.fetch
+  let fetchCalls: Array<{ url: string; options?: RequestInit }> = []
+  let fetchResponses: Response[] = []
+  let fetchIndex = 0
+
+  beforeEach(() => {
+    fetchCalls = []
+    fetchResponses = []
+    fetchIndex = 0
+    ;(globalThis as { fetch: 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(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    )
+  }
+
+  describe('listMessages', () => {
+    it('limits group-space history to messages that mention the bot', async () => {
+      mockResponse({ id: 'group-room', title: 'Team', type: 'group' })
+      mockResponse({ items: [{ id: 'msg-1', roomId: 'group-room', roomType: 'group' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const messages = await client.listMessages('group-room', { max: 5 })
+
+      expect(messages).toHaveLength(1)
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/rooms/group-room')
+
+      const messagesUrl = new URL(fetchCalls[1].url)
+      expect(messagesUrl.origin + messagesUrl.pathname).toBe('https://webexapis.com/v1/messages')
+      expect(messagesUrl.searchParams.get('roomId')).toBe('group-room')
+      expect(messagesUrl.searchParams.get('max')).toBe('5')
+      expect(messagesUrl.searchParams.get('mentionedPeople')).toBe('me')
+    })
+
+    it('does not add mentionedPeople for direct spaces', async () => {
+      mockResponse({ id: 'direct-room', title: 'DM', type: 'direct' })
+      mockResponse({ items: [{ id: 'msg-1', roomId: 'direct-room', roomType: 'direct' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.listMessages('direct-room', { max: 5 })
+
+      const messagesUrl = new URL(fetchCalls[1].url)
+      expect(messagesUrl.searchParams.get('roomId')).toBe('direct-room')
+      expect(messagesUrl.searchParams.get('mentionedPeople')).toBeNull()
+    })
+  })
+
+  describe('sendMessage threading', () => {
+    it('includes parentId in the request body when threading', async () => {
+      mockResponse({ id: 'msg-1', roomId: 'room-1', roomType: 'group' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage('room-1', 'reply text', { parentId: 'parent-1' })
+
+      const body = JSON.parse(fetchCalls[0].options?.body as string)
+      expect(body.roomId).toBe('room-1')
+      expect(body.text).toBe('reply text')
+      expect(body.parentId).toBe('parent-1')
+    })
+  })
+
+  describe('listReplies', () => {
+    it('queries messages filtered by parentId', async () => {
+      mockResponse({ items: [{ id: 'reply-1', roomId: 'room-1', roomType: 'group', parentId: 'parent-1' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const replies = await client.listReplies('room-1', 'parent-1', { max: 10 })
+
+      expect(replies).toHaveLength(1)
+      const url = new URL(fetchCalls[0].url)
+      expect(url.searchParams.get('roomId')).toBe('room-1')
+      expect(url.searchParams.get('parentId')).toBe('parent-1')
+      expect(url.searchParams.get('max')).toBe('10')
+    })
+  })
+
+  describe('getPerson', () => {
+    it('fetches a person by id', async () => {
+      mockResponse({ id: 'person-1', emails: ['a@b.com'], displayName: 'Alice', type: 'person' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const person = await client.getPerson('person-1')
+
+      expect(person.displayName).toBe('Alice')
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/people/person-1')
+    })
+  })
+
+  describe('uploadFile', () => {
+    it('posts multipart form data to messages', async () => {
+      mockResponse({
+        id: 'msg-1',
+        roomId: 'room-1',
+        roomType: 'group',
+        files: ['https://webexapis.com/v1/contents/c1'],
+      })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const message = await client.uploadFile(
+        'room-1',
+        { content: new Blob(['hello']), filename: 'note.txt' },
+        { text: 'see attached' },
+      )
+
+      expect(message.files).toEqual(['https://webexapis.com/v1/contents/c1'])
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/messages')
+      expect(fetchCalls[0].options?.method).toBe('POST')
+      const body = fetchCalls[0].options?.body as FormData
+      expect(body).toBeInstanceOf(FormData)
+      expect(body.get('roomId')).toBe('room-1')
+      expect(body.get('text')).toBe('see attached')
+    })
+  })
+
+  describe('downloadContent', () => {
+    it('returns binary data with filename parsed from Content-Disposition', async () => {
+      fetchResponses.push(
+        new Response('binary-bytes', {
+          status: 200,
+          headers: {
+            'Content-Disposition': 'attachment; filename="report.pdf"',
+            'Content-Type': 'application/pdf',
+          },
+        }),
+      )
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('https://webexapis.com/v1/contents/c1')
+
+      expect(result.filename).toBe('report.pdf')
+      expect(result.contentType).toBe('application/pdf')
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/contents/c1')
+    })
+
+    it('builds the contents URL from a bare content id', async () => {
+      fetchResponses.push(new Response('data', { status: 200, headers: {} }))
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('abc123')
+
+      expect(fetchCalls[0].url).toBe('https://webexapis.com/v1/contents/abc123')
+      expect(result.filename).toBe('abc123')
+    })
+
+    it('refuses to download from a non-Webex host', async () => {
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+
+      await expect(client.downloadContent('https://attacker.example/file')).rejects.toThrow(/untrusted/i)
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('refuses to download over plain http from the Webex host', async () => {
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+
+      await expect(client.downloadContent('http://webexapis.com/v1/contents/c1')).rejects.toThrow(/untrusted/i)
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('sanitizes a path-traversal filename from Content-Disposition', async () => {
+      fetchResponses.push(
+        new Response('data', {
+          status: 200,
+          headers: { 'Content-Disposition': 'attachment; filename="../../etc/passwd"' },
+        }),
+      )
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      const result = await client.downloadContent('https://webexapis.com/v1/contents/c1')
+
+      expect(result.filename).toBe('passwd')
+    })
+  })
+
+  describe('room cluster resolution', () => {
+    const roomUuid = '12345678-1234-1234-1234-1234567890ab'
+    const usRoomId = toRestId(roomUuid, 'ROOM')
+    const clusteredRoomId = Buffer.from(`ciscospark://urn:TEAM:us-west-2_r/ROOM/${roomUuid}`).toString('base64url')
+
+    const isRoomsList = (url: string) => new URL(url).pathname === '/v1/rooms'
+
+    const clusteredId = (uuid: string) =>
+      Buffer.from(`ciscospark://urn:TEAM:us-west-2_r/ROOM/${uuid}`).toString('base64url')
+
+    const mockRoomsPage = (items: unknown[], nextCursor?: string) => {
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+      if (nextCursor) headers.Link = `<https://webexapis.com/v1/rooms?max=1000&before=${nextCursor}>; rel="next"`
+      fetchResponses.push(new Response(JSON.stringify({ items }), { status: 200, headers }))
+    }
+
+    it('rewrites a us-cluster roomId to the real urn:TEAM id before sending', async () => {
+      // given a non-default-cluster room only reachable via its clustered id
+      mockResponse({ items: [{ id: clusteredRoomId, title: 'Team', type: 'group' }] })
+      mockResponse({ id: 'msg-1', roomId: clusteredRoomId, roomType: 'group' })
+
+      // when sending to the us-flattened id the listener emitted
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage(usRoomId, 'hello')
+
+      // then the lookup runs and the send targets the corrected clustered id
+      expect(isRoomsList(fetchCalls[0].url)).toBe(true)
+      const body = JSON.parse(fetchCalls[1].options?.body as string)
+      expect(body.roomId).toBe(clusteredRoomId)
+    })
+
+    it('routes listMemberships through the corrected clustered id', async () => {
+      mockResponse({ items: [{ id: clusteredRoomId, type: 'group' }] })
+      mockResponse({ items: [{ id: 'm1', roomId: clusteredRoomId, personId: 'p1' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.listMemberships(usRoomId)
+
+      const membershipsUrl = new URL(fetchCalls[1].url)
+      expect(membershipsUrl.pathname).toBe('/v1/memberships')
+      expect(membershipsUrl.searchParams.get('roomId')).toBe(clusteredRoomId)
+    })
+
+    it('routes listMessages and its space lookup through the corrected clustered id', async () => {
+      mockResponse({ items: [{ id: clusteredRoomId, type: 'group' }] })
+      mockResponse({ id: clusteredRoomId, title: 'Team', type: 'group' })
+      mockResponse({ items: [{ id: 'msg-1', roomId: clusteredRoomId, roomType: 'group' }] })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.listMessages(usRoomId, { max: 5 })
+
+      expect(fetchCalls[1].url).toBe(`https://webexapis.com/v1/rooms/${clusteredRoomId}`)
+      const messagesUrl = new URL(fetchCalls[2].url)
+      expect(messagesUrl.searchParams.get('roomId')).toBe(clusteredRoomId)
+    })
+
+    it('passes an already-clustered roomId through without a lookup', async () => {
+      mockResponse({ id: 'msg-1', roomId: clusteredRoomId, roomType: 'group' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage(clusteredRoomId, 'hi')
+
+      expect(fetchCalls).toHaveLength(1)
+      expect(new URL(fetchCalls[0].url).pathname).toBe('/v1/messages')
+      expect(JSON.parse(fetchCalls[0].options?.body as string).roomId).toBe(clusteredRoomId)
+    })
+
+    it('caches the resolution so repeated calls trigger one room lookup', async () => {
+      mockResponse({ items: [{ id: clusteredRoomId, type: 'group' }] })
+      mockResponse({ id: 'msg-1', roomId: clusteredRoomId })
+      mockResponse({ id: 'msg-2', roomId: clusteredRoomId })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage(usRoomId, 'a')
+      await client.sendMessage(usRoomId, 'b')
+
+      expect(fetchCalls.filter((c) => isRoomsList(c.url))).toHaveLength(1)
+    })
+
+    it('follows Link pages until the room is found on a later page', async () => {
+      // given the matching room is only on the second page
+      mockRoomsPage([{ id: clusteredId('00000000-0000-0000-0000-000000000000'), type: 'group' }], 'cursor1')
+      mockRoomsPage([{ id: clusteredRoomId, type: 'group' }])
+      mockResponse({ id: 'msg-1', roomId: clusteredRoomId, roomType: 'group' })
+
+      // when sending to a room not present on the first page
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage(usRoomId, 'hi')
+
+      // then the second page is fetched via the Link cursor and the send targets the match
+      expect(isRoomsList(fetchCalls[0].url)).toBe(true)
+      expect(isRoomsList(fetchCalls[1].url)).toBe(true)
+      expect(fetchCalls[1].url).toContain('before=cursor1')
+      expect(JSON.parse(fetchCalls[2].options?.body as string).roomId).toBe(clusteredRoomId)
+    })
+
+    it('stops paging once the room is found and does not fetch later pages', async () => {
+      // given a first page that already contains the match but still advertises a next page
+      mockRoomsPage([{ id: clusteredRoomId, type: 'group' }], 'cursor1')
+      mockResponse({ id: 'msg-1', roomId: clusteredRoomId, roomType: 'group' })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await client.sendMessage(usRoomId, 'hi')
+
+      // then only the first page is fetched (a second page fetch would hit the unmocked response and throw)
+      expect(fetchCalls.filter((c) => isRoomsList(c.url))).toHaveLength(1)
+      expect(JSON.parse(fetchCalls[1].options?.body as string).roomId).toBe(clusteredRoomId)
+    })
+
+    it('fails open to the un-clustered id and warns when no room matches', async () => {
+      const warnSpy = spyOn(console, 'warn').mockImplementation(() => {})
+      mockResponse({ items: [] })
+      mockResponse({ id: 'msg-1', roomId: usRoomId })
+
+      const client = await new WebexBotClient().login({ token: 'bot-token' })
+      await expect(client.sendMessage(usRoomId, 'x')).resolves.toBeDefined()
+
+      expect(JSON.parse(fetchCalls[1].options?.body as string).roomId).toBe(usRoomId)
+      expect(warnSpy).toHaveBeenCalled()
+      warnSpy.mockRestore()
+    })
+  })
+})

package/src/platforms/webexbot/client.ts

@@ -2,10 +2,33 @@ import { WebexClient } from '../webex/client'
 import type { WebexMembership, WebexMessage, WebexPerson, WebexSpace } from '../webex/types'
 import { WebexBotError } from './types'
 
+interface DecodedWebexId {
+  cluster: string
+  type: string
+  uuid: string
+}
+
+// Webex REST ids are base64(url) of `ciscospark://<cluster>/<TYPE>/<uuid>`; the
+// cluster correction needs all three parts, not just the <uuid> `fromRestId` returns.
+function decodeWebexId(restId: string): DecodedWebexId | null {
+  if (!restId) return null
+  const decoded = Buffer.from(restId, 'base64').toString('utf-8')
+  const match = decoded.match(/^ciscospark:\/\/([^/]+)\/([^/]+)\/(.+)$/)
+  if (!match) return null
+  return { cluster: match[1], type: match[2], uuid: match[3] }
+}
+
 export class WebexBotClient {
   private client = new WebexClient()
   private token: string | null = null
 
+  // The listener flattens room ids to `ciscospark://us/ROOM/<uuid>`, but team/group
+  // rooms live on `ciscospark://urn:TEAM:<cluster>/ROOM/<uuid>` — a cluster the bare
+  // uuid cannot recover. Cache the real clustered id per uuid and dedupe concurrent
+  // lookups so a burst of calls triggers a single `listSpaces`.
+  private clusteredRoomIds = new Map<string, string>()
+  private roomIdLookups = new Map<string, Promise<string>>()
+
   async login(credentials?: { token: string }): Promise<this> {
     if (credentials) {
       if (!credentials.token) {
@@ -41,22 +64,37 @@ export class WebexBotClient {
   }
 
   async getSpace(spaceId: string): Promise<WebexSpace> {
-    return this.client.getSpace(spaceId)
+    return this.client.getSpace(await this.resolveRoomId(spaceId))
   }
 
-  async sendMessage(roomId: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
-    return this.client.sendMessage(roomId, text, options)
+  async sendMessage(
+    roomId: string,
+    text: string,
+    options?: { markdown?: boolean; parentId?: string; files?: string[] },
+  ): Promise<WebexMessage> {
+    return this.client.sendMessage(await this.resolveRoomId(roomId), text, options)
   }
 
   async sendDirectMessage(personEmail: string, text: string, options?: { markdown?: boolean }): Promise<WebexMessage> {
     return this.client.sendDirectMessage(personEmail, text, options)
   }
 
-  async listMessages(roomId: string, options?: { max?: number }): Promise<WebexMessage[]> {
-    return this.client.listMessages(roomId, options)
+  async listMessages(roomId: string, options?: { max?: number; parentId?: string }): Promise<WebexMessage[]> {
+    const resolvedRoomId = await this.resolveRoomId(roomId)
+    const space = await this.client.getSpace(resolvedRoomId)
+    const messageOptions = space.type === 'group' ? { ...options, mentionedPeople: 'me' } : options
+    return this.client.listMessages(resolvedRoomId, messageOptions)
+  }
+
+  async listReplies(roomId: string, parentId: string, options?: { max?: number }): Promise<WebexMessage[]> {
+    return this.client.listMessages(await this.resolveRoomId(roomId), { ...options, parentId })
   }
 
   async getMessage(messageId: string): Promise<WebexMessage> {
+    // MESSAGE ids carry their parent room's cluster, which the bare-UUID normalizer
+    // also flattens to `us`. Correcting that needs the room context, which a lone
+    // messageId does not provide; room-keyed calls (the reported failures) are
+    // corrected via resolveRoomId instead.
     return this.client.getMessage(messageId)
   }
 
@@ -70,18 +108,77 @@ export class WebexBotClient {
     text: string,
     options?: { markdown?: boolean },
   ): Promise<WebexMessage> {
-    return this.client.editMessage(messageId, roomId, text, options)
+    return this.client.editMessage(messageId, await this.resolveRoomId(roomId), text, options)
   }
 
   async listPeople(options?: { email?: string; displayName?: string; max?: number }): Promise<WebexPerson[]> {
     return this.client.listPeople(options)
   }
 
+  async getPerson(personId: string): Promise<WebexPerson> {
+    return this.client.getPerson(personId)
+  }
+
   async listMyMemberships(options?: { max?: number }): Promise<WebexMembership[]> {
     return this.client.listMyMemberships(options)
   }
 
   async listMemberships(roomId: string, options?: { max?: number }): Promise<WebexMembership[]> {
-    return this.client.listMemberships(roomId, options)
+    return this.client.listMemberships(await this.resolveRoomId(roomId), options)
+  }
+
+  async uploadFile(
+    roomId: string,
+    file: { content: Blob; filename: string },
+    options?: { text?: string; markdown?: boolean; parentId?: string },
+  ): Promise<WebexMessage> {
+    return this.client.uploadFile(await this.resolveRoomId(roomId), file, options)
+  }
+
+  async downloadContent(contentRef: string): Promise<{ data: ArrayBuffer; filename: string; contentType: string }> {
+    return this.client.downloadContent(contentRef)
+  }
+
+  private async resolveRoomId(roomId: string): Promise<string> {
+    const decoded = decodeWebexId(roomId)
+    // Already cluster-qualified or undecodable: nothing to correct.
+    if (!decoded || decoded.cluster.startsWith('urn:')) return roomId
+
+    const { uuid } = decoded
+    const cached = this.clusteredRoomIds.get(uuid)
+    if (cached) return cached
+
+    const inFlight = this.roomIdLookups.get(uuid)
+    if (inFlight) return inFlight
+
+    const lookup = this.lookupRoomId(uuid, roomId)
+    this.roomIdLookups.set(uuid, lookup)
+    try {
+      return await lookup
+    } finally {
+      this.roomIdLookups.delete(uuid)
+    }
+  }
+
+  private async lookupRoomId(uuid: string, fallback: string): Promise<string> {
+    try {
+      // Page through every room the bot belongs to (largest page size, following
+      // `Link` pages), stopping as soon as the trailing UUID matches.
+      for await (const room of this.client.iterateSpaces({ max: 1000 })) {
+        if (decodeWebexId(room.id)?.uuid === uuid) {
+          this.clusteredRoomIds.set(uuid, room.id)
+          return room.id
+        }
+      }
+    } catch {
+      // Network/auth failure: fail open to the un-corrected id rather than block the call.
+      return fallback
+    }
+
+    console.warn(
+      `[webexbot] Could not resolve clustered room id for ${uuid}; falling back to the un-clustered id. ` +
+        'Room-scoped calls may fail if this room lives on a non-default Webex cluster.',
+    )
+    return fallback
   }
 }

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'