agent-messenger 2.38.0 → 2.39.0

package/src/platforms/discordbot/commands/file.test.ts

@@ -1,15 +1,95 @@
 import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { basename, join } from 'node:path'
+
+import type { DiscordCreateMessageOptions, DiscordFile, DiscordMessage } from '../types'
+
+const mockCreateMessage = mock(
+  async (channelId: string, options: DiscordCreateMessageOptions): Promise<DiscordMessage> => {
+    const files = options.files ?? []
+    const sizes = await Promise.all(files.map(async (file) => (await readFile(file.path)).length))
+    return {
+      id: 'msg-upload',
+      channel_id: channelId,
+      author: { id: 'bot-123', username: 'bot' },
+      content: options.content ?? '',
+      timestamp: new Date().toISOString(),
+      attachments: files.map((file, index) => ({
+        id: `att${index + 1}`,
+        filename: file.filename ?? basename(file.path),
+        size: sizes[index],
+        url: `https://cdn.discord.com/attachments/${channelId}/${file.filename ?? basename(file.path)}`,
+      })),
+    }
+  },
+)
+
+const mockListFiles = mock(
+  (_channelId: string): Promise<DiscordFile[]> =>
+    Promise.resolve([
+      { id: 'att1', filename: 'test.txt', size: 12, url: 'https://cdn.discord.com/test.txt' },
+      {
+        id: 'att2',
+        filename: 'report.pdf',
+        size: 2048,
+        url: 'https://cdn.discord.com/report.pdf',
+        content_type: 'application/pdf',
+      },
+    ]),
+)
+
+const mockFindFile = mock((_channelId: string, fileId: string): Promise<DiscordFile | undefined> => {
+  if (fileId === 'att1') {
+    return Promise.resolve({ id: 'att1', filename: 'test.txt', size: 12, url: 'https://cdn.discord.com/test.txt' })
+  }
+  return Promise.resolve(undefined)
+})
+
+const mockResolveChannel = mock((_guildId: string, channel: string): Promise<string> => {
+  if (channel === 'general') return Promise.resolve('ch-general')
+  if (/^\d+$/.test(channel)) return Promise.resolve(channel)
+  return Promise.reject(new Error(`Channel not found: "${channel}". Use channel ID or exact channel name.`))
+})
+
+const mockResolveThread = mock((_guildId: string, _parentChannelId: string, thread: string): Promise<string> => {
+  if (thread === 'release-discussion') return Promise.resolve('thread-1')
+  return Promise.reject(new Error(`Thread not found: "${thread}".`))
+})
+
+mock.module('../client', () => ({
+  DiscordBotClient: class MockDiscordBotClient {
+    async login(_credentials?: unknown) {
+      return this
+    }
+    createMessage = mockCreateMessage
+    listFiles = mockListFiles
+    findFile = mockFindFile
+    resolveChannel = mockResolveChannel
+    resolveThread = mockResolveThread
+  },
+}))
 
 import { DiscordBotCredentialManager } from '../credential-manager'
-import { listAction, uploadAction } from './file'
+import { infoAction, listAction, uploadAction } from './file'
 import type { BotOption } from './shared'
 
 describe('file commands', () => {
   let mockCredManager: DiscordBotCredentialManager
   let options: BotOption
-  const originalFetch = globalThis.fetch
+  let tempDir: string
+  let fileA: string
+  let fileB: string
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `discordbot-file-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    fileA = join(tempDir, 'a.txt')
+    fileB = join(tempDir, 'b.txt')
+    await Bun.write(fileA, 'file-a')
+    await Bun.write(fileB, 'file-b')
 
-  beforeEach(() => {
     mockCredManager = {
       getCurrentServer: mock(async () => 'server-123'),
       getCredentials: mock(async () => ({
@@ -19,47 +99,11 @@ describe('file commands', () => {
       })),
     } as unknown as DiscordBotCredentialManager
 
-    ;(globalThis as Record<string, unknown>).fetch = async (url: string | URL | Request): Promise<Response> => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/guilds/') && urlStr.includes('/channels')) {
-        return new Response(JSON.stringify([{ id: 'ch-general', guild_id: 'server-123', name: 'general', type: 0 }]), {
-          status: 200,
-          headers: {
-            'Content-Type': 'application/json',
-            'X-RateLimit-Remaining': '10',
-            'X-RateLimit-Reset': String(Date.now() / 1000 + 60),
-            'X-RateLimit-Bucket': 'test-bucket',
-          },
-        })
-      }
-
-      if (urlStr.includes('/channels/') && urlStr.includes('/messages')) {
-        return new Response(
-          JSON.stringify([
-            {
-              id: 'msg1',
-              channel_id: 'ch-general',
-              author: { id: 'bot-123', username: 'bot' },
-              content: '',
-              timestamp: new Date().toISOString(),
-              attachments: [{ id: 'att1', filename: 'test.txt', size: 12, url: 'https://cdn.discord.com/test.txt' }],
-            },
-          ]),
-          {
-            status: 200,
-            headers: {
-              'Content-Type': 'application/json',
-              'X-RateLimit-Remaining': '10',
-              'X-RateLimit-Reset': String(Date.now() / 1000 + 60),
-              'X-RateLimit-Bucket': 'test-bucket',
-            },
-          },
-        )
-      }
-
-      return new Response(JSON.stringify({ message: 'Not Found' }), { status: 404 })
-    }
+    mockCreateMessage.mockClear()
+    mockListFiles.mockClear()
+    mockFindFile.mockClear()
+    mockResolveChannel.mockClear()
+    mockResolveThread.mockClear()
 
     options = {
       _credManager: mockCredManager,
@@ -67,78 +111,186 @@ describe('file commands', () => {
   })
 
   afterEach(() => {
-    globalThis.fetch = originalFetch
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true })
+    }
   })
 
   describe('uploadAction', () => {
-    it('uploads file successfully', async () => {
-      const result = await uploadAction('general', './test.txt', {
-        ...options,
-        _credManager: mockCredManager,
+    it('uploads a file and returns file, files, message_id, and channel_id', async () => {
+      const result = await uploadAction('general', [fileA], options)
+
+      expect(result.error).toBeUndefined()
+      expect(result.success).toBe(true)
+      expect(result.message_id).toBe('msg-upload')
+      expect(result.channel_id).toBe('ch-general')
+      expect(result.files).toHaveLength(1)
+      expect(result.file).toEqual(result.files?.[0])
+      expect(result.file?.filename).toBe('a.txt')
+      expect(result.file?.size).toBe(6)
+      expect(mockCreateMessage).toHaveBeenCalledWith('ch-general', {
+        content: undefined,
+        files: [{ path: fileA, filename: undefined }],
+        reply_to: undefined,
       })
+    })
+
+    it('uploads multiple files in one message', async () => {
+      const result = await uploadAction('general', [fileA, fileB], options)
 
-      expect(result).toBeDefined()
+      expect(result.error).toBeUndefined()
+      expect(result.files).toHaveLength(2)
+      expect(result.files?.map((file) => file.filename)).toEqual(['a.txt', 'b.txt'])
+      expect(result.file).toEqual(result.files?.[0])
+      expect(mockCreateMessage).toHaveBeenCalledWith('ch-general', {
+        content: undefined,
+        files: [
+          { path: fileA, filename: undefined },
+          { path: fileB, filename: undefined },
+        ],
+        reply_to: undefined,
+      })
     })
 
-    it('returns error when channel resolution fails', async () => {
-      const result = await uploadAction('nonexistent', './test.txt', options)
-      expect(result.error).toBeDefined()
+    it('sends text with the files', async () => {
+      const result = await uploadAction('general', [fileA], { ...options, text: 'see attached' })
+
+      expect(result.error).toBeUndefined()
+      expect(mockCreateMessage).toHaveBeenCalledWith('ch-general', {
+        content: 'see attached',
+        files: [{ path: fileA, filename: undefined }],
+        reply_to: undefined,
+      })
     })
 
-    it('returns error when file does not exist', async () => {
-      const result = await uploadAction('general', '/nonexistent/file.txt', {
-        ...options,
-        _credManager: mockCredManager,
+    it('uploads into a thread by name', async () => {
+      const result = await uploadAction('general', [fileA], { ...options, thread: 'release-discussion' })
+
+      expect(result.error).toBeUndefined()
+      expect(mockResolveThread).toHaveBeenCalledWith('server-123', 'ch-general', 'release-discussion')
+      expect(mockCreateMessage).toHaveBeenCalledWith('thread-1', {
+        content: undefined,
+        files: [{ path: fileA, filename: undefined }],
+        reply_to: undefined,
       })
+      expect(result.channel_id).toBe('thread-1')
+    })
+
+    it('replies to a message when --reply is given', async () => {
+      const result = await uploadAction('general', [fileA], { ...options, reply: 'msg1' })
+
+      expect(result.error).toBeUndefined()
+      expect(mockCreateMessage).toHaveBeenCalledWith('ch-general', {
+        content: undefined,
+        files: [{ path: fileA, filename: undefined }],
+        reply_to: 'msg1',
+      })
+    })
+
+    it('rejects --filename with multiple files before any client call', async () => {
+      const result = await uploadAction('general', [fileA, fileB], { ...options, filename: 'x.txt' })
+
+      expect(result.error).toBe('--filename requires exactly one file')
+      expect(mockResolveChannel).not.toHaveBeenCalled()
+      expect(mockCreateMessage).not.toHaveBeenCalled()
+    })
+
+    it('renames the uploaded part with --filename', async () => {
+      const result = await uploadAction('general', [fileA], { ...options, filename: 'renamed.txt' })
+
+      expect(result.error).toBeUndefined()
+      expect(result.file?.filename).toBe('renamed.txt')
+      expect(mockCreateMessage).toHaveBeenCalledWith('ch-general', {
+        content: undefined,
+        files: [{ path: fileA, filename: 'renamed.txt' }],
+        reply_to: undefined,
+      })
+    })
+
+    it('returns an error when a file does not exist', async () => {
+      const result = await uploadAction('general', [join(tempDir, 'missing.txt')], options)
+
+      expect(result.error).toContain('ENOENT')
+    })
+
+    it('returns an error when more than 10 files are given', async () => {
+      mockCreateMessage.mockImplementationOnce(() =>
+        Promise.reject(new Error('Discord allows at most 10 files per message')),
+      )
+      const paths = Array.from({ length: 11 }, (_, i) => join(tempDir, `f${i}.txt`))
+      const result = await uploadAction('general', paths, options)
+
+      expect(result.error).toContain('10')
+    })
+
+    it('returns error when channel resolution fails', async () => {
+      const result = await uploadAction('nonexistent', [fileA], options)
+
       expect(result.error).toBeDefined()
+      expect(mockCreateMessage).not.toHaveBeenCalled()
     })
   })
 
-  describe('listAction', () => {
-    it('lists files successfully', async () => {
-      const result = await listAction('general', {
-        ...options,
-        _credManager: mockCredManager,
-      })
+  describe('infoAction', () => {
+    it('returns file info for an existing file without listing the channel', async () => {
+      const result = await infoAction('general', 'att1', options)
 
-      expect(result).toBeDefined()
+      expect(result.error).toBeUndefined()
+      expect(result.id).toBe('att1')
+      expect(result.filename).toBe('test.txt')
+      expect(result.size).toBe(12)
+      expect(result.url).toBe('https://cdn.discord.com/test.txt')
+      expect(result.content_type).toBeNull()
+      expect(mockFindFile).toHaveBeenCalledWith('ch-general', 'att1')
+      expect(mockListFiles).not.toHaveBeenCalled()
+    })
+
+    it('returns error when file is not found', async () => {
+      const result = await infoAction('general', 'nope', options)
+
+      expect(result.error).toBe('File not found: nope')
+      expect(mockFindFile).toHaveBeenCalledWith('ch-general', 'nope')
     })
 
     it('returns error when channel resolution fails', async () => {
-      const result = await listAction('nonexistent', options)
+      const result = await infoAction('nonexistent', 'att1', options)
+
       expect(result.error).toBeDefined()
+      expect(mockFindFile).not.toHaveBeenCalled()
+      expect(mockListFiles).not.toHaveBeenCalled()
     })
   })
 
-  describe('action result structure', () => {
-    it('returns success result with file info for uploadAction', async () => {
-      const result = await uploadAction('general', './test.txt', {
-        ...options,
-        _credManager: mockCredManager,
-      })
+  describe('listAction', () => {
+    it('lists files in channel', async () => {
+      const result = await listAction('general', options)
 
-      if (!result.error) {
-        expect(result.success).toBe(true)
-        expect(result.file).toBeDefined()
-        if (result.file) {
-          expect(result.file.id).toBeDefined()
-          expect(result.file.filename).toBeDefined()
-          expect(result.file.size).toBeDefined()
-          expect(result.file.url).toBeDefined()
-        }
-      }
+      expect(result.error).toBeUndefined()
+      expect(result.success).toBe(true)
+      expect(mockListFiles).toHaveBeenCalledWith('ch-general')
+      expect(mockFindFile).not.toHaveBeenCalled()
+      expect(result.files).toEqual([
+        {
+          id: 'att1',
+          filename: 'test.txt',
+          size: 12,
+          url: 'https://cdn.discord.com/test.txt',
+          content_type: null,
+        },
+        {
+          id: 'att2',
+          filename: 'report.pdf',
+          size: 2048,
+          url: 'https://cdn.discord.com/report.pdf',
+          content_type: 'application/pdf',
+        },
+      ])
     })
 
-    it('returns success result with files array for listAction', async () => {
-      const result = await listAction('general', {
-        ...options,
-        _credManager: mockCredManager,
-      })
+    it('returns error when channel resolution fails', async () => {
+      const result = await listAction('nonexistent', options)
 
-      if (!result.error) {
-        expect(result.success).toBe(true)
-        expect(Array.isArray(result.files)).toBe(true)
-      }
+      expect(result.error).toBeDefined()
     })
   })
 })

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

@@ -5,48 +5,60 @@ import { Command } from 'commander'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 
-import type { DiscordFile } from '../types'
-import type { BotOption } from './shared'
-import { getClient, getCurrentServer } from './shared'
-
-interface FileOutput {
-  id: string
-  filename: string
-  size: number
-  url: string
-  content_type?: string | null
+import type { AttachmentOutput, BotOption, SendTargetOption } from './shared'
+import { getClient, getCurrentServer, resolveSendTarget, toAttachmentOutput } from './shared'
+
+export interface UploadOption extends SendTargetOption {
+  text?: string
+  filename?: string
 }
 
 interface UploadActionResult {
   success?: boolean
   error?: string
-  file?: FileOutput
+  file?: AttachmentOutput
+  files?: AttachmentOutput[]
+  message_id?: string
+  channel_id?: string
 }
 
 interface ListActionResult {
   success?: boolean
   error?: string
-  files?: FileOutput[]
+  files?: AttachmentOutput[]
 }
 
-export async function uploadAction(channel: string, filePath: string, options: BotOption): Promise<UploadActionResult> {
+type InfoActionResult = AttachmentOutput | { error: string }
+
+export async function uploadAction(
+  channel: string,
+  filePaths: string[],
+  options: UploadOption,
+): Promise<UploadActionResult> {
   try {
+    if (options.filename !== undefined && filePaths.length > 1) {
+      return { error: '--filename requires exactly one file' }
+    }
+
     const serverId = await getCurrentServer(options)
     const client = await getClient(options)
-    const channelId = await client.resolveChannel(serverId, channel)
+    const { channelId, threadId } = await resolveSendTarget(client, serverId, channel, options.thread)
 
-    const resolvedPath = resolve(filePath)
-    const file = await client.uploadFile(channelId, resolvedPath)
+    const message = await client.createMessage(threadId ?? channelId, {
+      content: options.text,
+      files: filePaths.map((filePath) => ({ path: resolve(filePath), filename: options.filename })),
+      reply_to: options.reply,
+    })
 
-    const output: FileOutput = {
-      id: file.id,
-      filename: file.filename,
-      size: file.size,
-      url: file.url,
-      content_type: file.content_type || null,
-    }
+    const files = toAttachmentOutput(message.attachments)
 
-    return { success: true, file: output }
+    return {
+      success: true,
+      file: files[0],
+      files,
+      message_id: message.id,
+      channel_id: message.channel_id,
+    }
   } catch (error) {
     return { error: (error as Error).message }
   }
@@ -60,15 +72,24 @@ export async function listAction(channel: string, options: BotOption): Promise<L
 
     const files = await client.listFiles(channelId)
 
-    const output = files.map((file: DiscordFile) => ({
-      id: file.id,
-      filename: file.filename,
-      size: file.size,
-      url: file.url,
-      content_type: file.content_type || null,
-    }))
+    return { success: true, files: toAttachmentOutput(files) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
 
-    return { success: true, files: output }
+export async function infoAction(channel: string, fileId: string, options: BotOption): Promise<InfoActionResult> {
+  try {
+    const serverId = await getCurrentServer(options)
+    const client = await getClient(options)
+    const channelId = await client.resolveChannel(serverId, channel)
+
+    const file = await client.findFile(channelId, fileId)
+    if (!file) {
+      return { error: `File not found: ${fileId}` }
+    }
+
+    return toAttachmentOutput([file])[0]
   } catch (error) {
     return { error: (error as Error).message }
   }
@@ -78,15 +99,36 @@ export const fileCommand = new Command('file')
   .description('File commands')
   .addCommand(
     new Command('upload')
-      .description('Upload file to channel')
+      .description('Upload one or more files to channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<file-path...>', 'One or more file paths (max 10)')
+      .option('--text <text>', 'Message text sent with the file(s)')
+      .option('--thread <id|name>', 'Post into this thread')
+      .option('--reply <message-id>', 'Reply to a message')
+      .option('--filename <name>', 'Override the filename (single file only)')
+      .option('--server <id>', 'Use specific server')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (channelArg: string, filePathArgs: string[], opts: UploadOption & BotOption) => {
+        try {
+          const result = await uploadAction(channelArg, filePathArgs, opts)
+          console.log(formatOutput(result, opts.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get file info')
       .argument('<channel>', 'Channel ID or name')
-      .argument('<file-path>', 'File path')
+      .argument('<file-id>', 'File ID')
       .option('--server <id>', 'Use specific server')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
-      .action(async (channelArg: string, filePathArg: string, options: BotOption) => {
+      .action(async (channelArg: string, fileIdArg: string, options: BotOption) => {
         try {
-          const result = await uploadAction(channelArg, filePathArg, options)
+          const result = await infoAction(channelArg, fileIdArg, options)
           console.log(formatOutput(result, options.pretty))
         } catch (error) {
           handleError(error as Error)