agent-messenger 2.37.2 → 2.38.0

package/src/platforms/discord/commands/emoji.test.ts

@@ -0,0 +1,122 @@
+import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { createAction, deleteAction, listAction } from './emoji'
+
+let clientListEmojisSpy: ReturnType<typeof spyOn>
+let clientCreateEmojiSpy: ReturnType<typeof spyOn>
+let clientDeleteEmojiSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+let tempDir: string
+const originalLog = console.log
+const originalExit = process.exit
+
+function pngBytes(width: number, height: number, padding = 0): Uint8Array {
+  const bytes = new Uint8Array(24 + padding)
+  bytes.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], 0)
+  bytes.set([0x00, 0x00, 0x00, 0x0d], 8)
+  bytes.set([0x49, 0x48, 0x44, 0x52], 12)
+  const view = new DataView(bytes.buffer)
+  view.setUint32(16, width)
+  view.setUint32(20, height)
+  return bytes
+}
+
+async function writeTempImage(filename: string, bytes: Uint8Array): Promise<string> {
+  const path = join(tempDir, filename)
+  await writeFile(path, bytes)
+  return path
+}
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), 'discord-emoji-'))
+
+  clientListEmojisSpy = spyOn(DiscordClient.prototype, 'listEmojis').mockResolvedValue([
+    { id: 'e1', name: 'potato_01', animated: false },
+    { id: 'e2', name: 'potato_02', animated: false },
+  ])
+
+  clientCreateEmojiSpy = spyOn(DiscordClient.prototype, 'createEmoji').mockResolvedValue({
+    id: 'e9',
+    name: 'potato_13',
+    animated: false,
+  })
+
+  clientDeleteEmojiSpy = spyOn(DiscordClient.prototype, 'deleteEmoji').mockResolvedValue(undefined)
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'server-1',
+    servers: {},
+  })
+})
+
+afterEach(async () => {
+  console.log = originalLog
+  process.exit = originalExit
+  await rm(tempDir, { recursive: true, force: true })
+  clientListEmojisSpy?.mockRestore()
+  clientCreateEmojiSpy?.mockRestore()
+  clientDeleteEmojiSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+it('list: reports the guild emoji with static and animated counts', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('g1', { pretty: false })
+
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('potato_01')
+  expect(output).toContain('"static_count":2')
+  expect(output).toContain('"animated_count":0')
+})
+
+it('create: uploads the image with its content type and derives the name from the filename', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const path = await writeTempImage('potato_13.png', pngBytes(128, 128))
+
+  await createAction('g1', path, { pretty: false })
+
+  expect(clientCreateEmojiSpy).toHaveBeenCalledWith('g1', 'potato_13', expect.any(Uint8Array), 'potato_13.png')
+  expect(consoleSpy.mock.calls[0][0]).toContain('potato_13')
+})
+
+it('create: prefers an explicit --name over the filename', async () => {
+  console.log = mock((_msg: string) => {})
+  const path = await writeTempImage('potato_13.png', pngBytes(128, 128))
+
+  await createAction('g1', path, { name: 'spud', pretty: false })
+
+  expect(clientCreateEmojiSpy.mock.calls[0][1]).toBe('spud')
+})
+
+it('delete: removes the emoji by id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('g1', 'e1', { pretty: false })
+
+  expect(clientDeleteEmojiSpy).toHaveBeenCalledWith('g1', 'e1')
+  expect(consoleSpy.mock.calls[0][0]).toContain('"success":true')
+})
+
+it('create: rejects a hyphenated name without calling the API', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  spyOn(process, 'exit').mockImplementation(() => {
+    throw new Error('exit')
+  })
+  const path = await writeTempImage('potato-13.png', pngBytes(128, 128))
+
+  await expect(createAction('g1', path, { pretty: false })).rejects.toThrow('exit')
+
+  expect(clientCreateEmojiSpy).not.toHaveBeenCalled()
+  expect(consoleSpy.mock.calls[0][0]).toContain('letters, digits, underscores')
+})

package/src/platforms/discord/commands/emoji.ts

@@ -0,0 +1,124 @@
+import { readFile } from 'node:fs/promises'
+import { basename, extname, resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { validateEmojiName } from '../expression-names'
+
+export async function listAction(serverId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const emojis = await client.listEmojis(serverId)
+    const staticCount = emojis.filter((emoji) => !emoji.animated).length
+
+    console.log(
+      formatOutput(
+        {
+          server_id: serverId,
+          count: emojis.length,
+          static_count: staticCount,
+          animated_count: emojis.length - staticCount,
+          emojis: emojis.map((emoji) => ({ id: emoji.id, name: emoji.name, animated: emoji.animated ?? false })),
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function createAction(
+  serverId: string,
+  path: string,
+  options: { name?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+
+    const filePath = resolve(path)
+    const filename = basename(filePath)
+    const name = options.name ?? basename(filename, extname(filename))
+
+    const nameError = validateEmojiName(name)
+    if (nameError) {
+      console.log(formatOutput({ error: nameError }, options.pretty))
+      process.exit(1)
+    }
+
+    const image = new Uint8Array(await readFile(filePath))
+
+    const emoji = await client.createEmoji(serverId, name, image, filename)
+
+    console.log(formatOutput({ success: true, server_id: serverId, id: emoji.id, name: emoji.name }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function deleteAction(serverId: string, emojiId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    await client.deleteEmoji(serverId, emojiId)
+
+    console.log(formatOutput({ success: true, server_id: serverId, id: emojiId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const emojiCommand = new Command('emoji')
+  .description('Custom emoji commands')
+  .addCommand(
+    new Command('list')
+      .description('List custom emoji in a server')
+      .argument('<server-id>', 'Server ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('create')
+      .description('Upload a custom emoji to a server')
+      .argument('<server-id>', 'Server ID')
+      .argument('<file>', 'Image file (PNG, JPEG, GIF or WebP, max 256KB)')
+      .option('--name <name>', 'Emoji name (defaults to the filename without extension)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a custom emoji from a server')
+      .argument('<server-id>', 'Server ID')
+      .argument('<emoji-id>', 'Emoji ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction),
+  )

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

@@ -1,6 +1,7 @@
 export { authCommand } from './auth'
 export { channelCommand } from './channel'
 export { dmCommand } from './dm'
+export { emojiCommand } from './emoji'
 export { fileCommand } from './file'
 export { friendCommand } from './friend'
 export { memberCommand } from './member'
@@ -11,6 +12,7 @@ export { profileCommand } from './profile'
 export { reactionCommand } from './reaction'
 export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
+export { stickerCommand } from './sticker'
 export { threadCommand } from './thread'
 export { userCommand } from './user'
 export { whoamiCommand } from './whoami'

package/src/platforms/discord/commands/server.test.ts

@@ -1,11 +1,13 @@
-import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
+import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { infoAction } from './server'
 
 let clientListServersSpy: ReturnType<typeof spyOn>
 let clientGetServerSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
+const originalLog = console.log
 let credManagerSetCurrentServerSpy: ReturnType<typeof spyOn>
 let credManagerGetCurrentServerSpy: ReturnType<typeof spyOn>
 
@@ -46,6 +48,7 @@ beforeEach(() => {
 })
 
 afterEach(() => {
+  console.log = originalLog
   clientListServersSpy?.mockRestore()
   clientGetServerSpy?.mockRestore()
   credManagerLoadSpy?.mockRestore()
@@ -132,3 +135,44 @@ it('current: returns current server info', async () => {
   expect(current).toBe('server-1')
   expect(config.current_server).toBe('server-1')
 })
+
+it('info: reports the boost tier, expression counts and remaining sticker slots', async () => {
+  clientGetServerSpy.mockResolvedValue({
+    id: 'server-1',
+    name: 'Server One',
+    icon: 'icon1',
+    owner_id: 'user-9',
+    premium_tier: 2,
+    premium_subscription_count: 8,
+    emojis: [{ id: 'e1', name: 'potato_01', animated: false }],
+    stickers: [{ id: 's1', name: 'potato_01', tags: 'potato', type: 2, format_type: 1 }],
+  })
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await infoAction('server-1', { pretty: false })
+
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('"owner_id":"user-9"')
+  expect(output).toContain('"premium_tier":2')
+  expect(output).toContain('"emoji_count":1')
+  expect(output).toContain('"sticker_count":1')
+  expect(output).toContain('"sticker_slots":30')
+  expect(output).toContain('"static_emoji_slots_remaining":149')
+})
+
+it('info: falls back to the base sticker allowance when the server has no boosts', async () => {
+  clientGetServerSpy.mockResolvedValue({
+    id: 'server-1',
+    name: 'Server One',
+    premium_tier: 0,
+    emojis: [],
+    stickers: [],
+  })
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await infoAction('server-1', { pretty: false })
+
+  expect(consoleSpy.mock.calls[0][0]).toContain('"sticker_slots":5')
+})

package/src/platforms/discord/commands/server.ts

@@ -6,6 +6,10 @@ import { formatOutput } from '@/shared/utils/output'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 
+/** Discord raises both allowances with the server's boost level. */
+const STATIC_EMOJI_SLOTS_BY_TIER = [50, 100, 150, 250]
+const STICKER_SLOTS_BY_TIER = [5, 15, 30, 60]
+
 export async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new DiscordCredentialManager()
@@ -37,11 +41,27 @@ export async function infoAction(serverId: string, options: { pretty?: boolean }
     const client = await new DiscordClient().login({ token: config.token })
     const server = await client.getServer(serverId)
 
+    const tier = server.premium_tier ?? 0
+    const emojis = server.emojis ?? []
+    const stickers = server.stickers ?? []
+    const staticEmojiCount = emojis.filter((emoji) => !emoji.animated).length
+
     const output = {
       id: server.id,
       name: server.name,
       icon: server.icon,
-      owner: server.owner,
+      owner_id: server.owner_id,
+      premium_tier: tier,
+      premium_subscription_count: server.premium_subscription_count ?? 0,
+      emoji_count: emojis.length,
+      sticker_count: stickers.length,
+      static_emoji_slots: STATIC_EMOJI_SLOTS_BY_TIER[tier] ?? STATIC_EMOJI_SLOTS_BY_TIER[0],
+      static_emoji_slots_remaining: Math.max(
+        0,
+        (STATIC_EMOJI_SLOTS_BY_TIER[tier] ?? STATIC_EMOJI_SLOTS_BY_TIER[0]) - staticEmojiCount,
+      ),
+      sticker_slots: STICKER_SLOTS_BY_TIER[tier] ?? STICKER_SLOTS_BY_TIER[0],
+      sticker_slots_remaining: Math.max(0, (STICKER_SLOTS_BY_TIER[tier] ?? STICKER_SLOTS_BY_TIER[0]) - stickers.length),
     }
 
     console.log(formatOutput(output, options.pretty))

package/src/platforms/discord/commands/sticker.test.ts

@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { createAction, deleteAction, listAction } from './sticker'
+
+let clientListStickersSpy: ReturnType<typeof spyOn>
+let clientCreateStickerSpy: ReturnType<typeof spyOn>
+let clientDeleteStickerSpy: ReturnType<typeof spyOn>
+let credManagerLoadSpy: ReturnType<typeof spyOn>
+let tempDir: string
+const originalLog = console.log
+const originalExit = process.exit
+
+function pngBytes(width: number, height: number, padding = 0): Uint8Array {
+  const bytes = new Uint8Array(24 + padding)
+  bytes.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], 0)
+  bytes.set([0x00, 0x00, 0x00, 0x0d], 8)
+  bytes.set([0x49, 0x48, 0x44, 0x52], 12)
+  const view = new DataView(bytes.buffer)
+  view.setUint32(16, width)
+  view.setUint32(20, height)
+  return bytes
+}
+
+async function writeTempImage(filename: string, bytes: Uint8Array): Promise<string> {
+  const path = join(tempDir, filename)
+  await writeFile(path, bytes)
+  return path
+}
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), 'discord-sticker-'))
+
+  clientListStickersSpy = spyOn(DiscordClient.prototype, 'listStickers').mockResolvedValue([
+    { id: 's1', name: 'potato_01', tags: 'potato', type: 2, format_type: 1 },
+  ])
+
+  clientCreateStickerSpy = spyOn(DiscordClient.prototype, 'createSticker').mockResolvedValue({
+    id: 's9',
+    name: 'potato_13',
+    tags: 'potato',
+    type: 2,
+    format_type: 1,
+  })
+
+  clientDeleteStickerSpy = spyOn(DiscordClient.prototype, 'deleteSticker').mockResolvedValue(undefined)
+
+  credManagerLoadSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue({
+    token: 'test-token',
+    current_server: 'server-1',
+    servers: {},
+  })
+})
+
+afterEach(async () => {
+  console.log = originalLog
+  process.exit = originalExit
+  await rm(tempDir, { recursive: true, force: true })
+  clientListStickersSpy?.mockRestore()
+  clientCreateStickerSpy?.mockRestore()
+  clientDeleteStickerSpy?.mockRestore()
+  credManagerLoadSpy?.mockRestore()
+})
+
+it('list: reports the guild stickers', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await listAction('g1', { pretty: false })
+
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('potato_01')
+  expect(output).toContain('"count":1')
+})
+
+it('create: uploads a 320x320 PNG with its multipart fields', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const path = await writeTempImage('potato_13.png', pngBytes(320, 320))
+
+  await createAction('g1', path, { tags: 'potato', description: 'a potato', pretty: false })
+
+  expect(clientCreateStickerSpy).toHaveBeenCalledWith(
+    'g1',
+    { name: 'potato_13', description: 'a potato', tags: 'potato' },
+    expect.any(Uint8Array),
+    'potato_13.png',
+  )
+  expect(consoleSpy.mock.calls[0][0]).toContain('potato_13')
+})
+
+it('delete: removes the sticker by id', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await deleteAction('g1', 's1', { pretty: false })
+
+  expect(clientDeleteStickerSpy).toHaveBeenCalledWith('g1', 's1')
+  expect(consoleSpy.mock.calls[0][0]).toContain('"success":true')
+})
+
+it('create: rejects a one-character name without calling the API', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  spyOn(process, 'exit').mockImplementation(() => {
+    throw new Error('exit')
+  })
+  const path = await writeTempImage('potato_13.png', pngBytes(320, 320))
+
+  await expect(createAction('g1', path, { name: '흥', tags: '😤', pretty: false })).rejects.toThrow('exit')
+
+  expect(clientCreateStickerSpy).not.toHaveBeenCalled()
+  expect(consoleSpy.mock.calls[0][0]).toContain('at least 2')
+})

package/src/platforms/discord/commands/sticker.ts

@@ -0,0 +1,135 @@
+import { readFile } from 'node:fs/promises'
+import { basename, extname, resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+import { validateStickerName } from '../expression-names'
+
+export async function listAction(serverId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const stickers = await client.listStickers(serverId)
+
+    console.log(
+      formatOutput(
+        {
+          server_id: serverId,
+          count: stickers.length,
+          stickers: stickers.map((sticker) => ({
+            id: sticker.id,
+            name: sticker.name,
+            tags: sticker.tags,
+            description: sticker.description ?? null,
+          })),
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function createAction(
+  serverId: string,
+  path: string,
+  options: { name?: string; description?: string; tags: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+
+    const filePath = resolve(path)
+    const filename = basename(filePath)
+    const name = options.name ?? basename(filename, extname(filename))
+
+    const nameError = validateStickerName(name)
+    if (nameError) {
+      console.log(formatOutput({ error: nameError }, options.pretty))
+      process.exit(1)
+    }
+
+    const image = new Uint8Array(await readFile(filePath))
+
+    const sticker = await client.createSticker(
+      serverId,
+      { name, description: options.description ?? '', tags: options.tags },
+      image,
+      filename,
+    )
+
+    console.log(
+      formatOutput({ success: true, server_id: serverId, id: sticker.id, name: sticker.name }, options.pretty),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function deleteAction(serverId: string, stickerId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    await client.deleteSticker(serverId, stickerId)
+
+    console.log(formatOutput({ success: true, server_id: serverId, id: stickerId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const stickerCommand = new Command('sticker')
+  .description('Custom sticker commands')
+  .addCommand(
+    new Command('list')
+      .description('List custom stickers in a server')
+      .argument('<server-id>', 'Server ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('create')
+      .description('Upload a custom sticker to a server')
+      .argument('<server-id>', 'Server ID')
+      .argument('<file>', 'Image file (PNG, APNG, GIF or Lottie JSON, max 512KB; Discord documents 320x320)')
+      .requiredOption('--tags <emoji>', 'Unicode emoji this sticker relates to')
+      .option('--name <name>', 'Sticker name (defaults to the filename without extension)')
+      .option('--description <text>', 'Sticker description')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a custom sticker from a server')
+      .argument('<server-id>', 'Server ID')
+      .argument('<sticker-id>', 'Sticker ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction),
+  )