agent-messenger 2.37.2 → 2.38.1

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.37.2
+version: 2.38.1
 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.37.2
+version: 2.38.1
 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.37.2
+version: 2.38.1
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

package/src/platforms/discord/cli.ts

@@ -8,6 +8,7 @@ import {
   authCommand,
   channelCommand,
   dmCommand,
+  emojiCommand,
   fileCommand,
   friendCommand,
   memberCommand,
@@ -18,6 +19,7 @@ import {
   reactionCommand,
   serverCommand,
   snapshotCommand,
+  stickerCommand,
   threadCommand,
   userCommand,
   whoamiCommand,
@@ -50,6 +52,7 @@ program.addCommand(authCommand)
 program.addCommand(serverCommand)
 program.addCommand(channelCommand)
 program.addCommand(dmCommand)
+program.addCommand(emojiCommand)
 program.addCommand(fileCommand)
 program.addCommand(friendCommand)
 program.addCommand(memberCommand)
@@ -59,6 +62,7 @@ program.addCommand(noteCommand)
 program.addCommand(profileCommand)
 program.addCommand(reactionCommand)
 program.addCommand(snapshotCommand)
+program.addCommand(stickerCommand)
 program.addCommand(threadCommand)
 program.addCommand(userCommand)
 program.addCommand(whoamiCommand)

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

@@ -1099,4 +1099,137 @@ describe('DiscordClient', () => {
       expect(result.totalUnread).toBe(7)
     })
   })
+  describe('expressions', () => {
+    const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+    it('listEmojis requests the guild emoji collection', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse([{ id: 'e1', name: 'potato_01', animated: false }])
+
+      const emojis = await client.listEmojis('g1')
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/emojis')
+      expect(fetchCalls[0].options?.method).toBe('GET')
+      expect(emojis[0].name).toBe('potato_01')
+    })
+
+    it('createEmoji posts the image as a base64 data URI', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse({ id: 'e1', name: 'potato_01', animated: false })
+
+      const emoji = await client.createEmoji('g1', 'potato_01', png, 'potato_01.png')
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/emojis')
+      expect(fetchCalls[0].options?.method).toBe('POST')
+      const body = JSON.parse(fetchCalls[0].options?.body as string)
+      expect(body.name).toBe('potato_01')
+      expect(body.image).toBe(`data:image/png;base64,${Buffer.from(png).toString('base64')}`)
+      expect(emoji.id).toBe('e1')
+    })
+
+    it('deleteEmoji issues a DELETE for the emoji', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse(null, 204)
+
+      await client.deleteEmoji('g1', 'e1')
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/emojis/e1')
+      expect(fetchCalls[0].options?.method).toBe('DELETE')
+    })
+
+    it('listStickers requests the guild sticker collection', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse([{ id: 's1', name: 'potato_01', tags: 'potato', type: 2, format_type: 1 }])
+
+      const stickers = await client.listStickers('g1')
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/stickers')
+      expect(fetchCalls[0].options?.method).toBe('GET')
+      expect(stickers[0].name).toBe('potato_01')
+    })
+
+    it('createSticker posts multipart fields alongside the file', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse({ id: 's1', name: 'potato_01', tags: 'potato', type: 2, format_type: 1 })
+
+      const sticker = await client.createSticker(
+        'g1',
+        { name: 'potato_01', description: 'a potato', tags: 'potato' },
+        png,
+        'potato_01.png',
+      )
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/stickers')
+      expect(fetchCalls[0].options?.method).toBe('POST')
+      const form = fetchCalls[0].options?.body as FormData
+      expect(form.get('name')).toBe('potato_01')
+      expect(form.get('description')).toBe('a potato')
+      expect(form.get('tags')).toBe('potato')
+      expect((form.get('file') as File).name).toBe('potato_01.png')
+      // Discord rejects a sticker part with no media type as "Invalid Asset".
+      expect((form.get('file') as File).type).toBe('image/png')
+      expect(sticker.id).toBe('s1')
+    })
+
+    it('createSticker types the part from the bytes, not the filename', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse({ id: 's2', name: 'potato_02', tags: 'potato', type: 2, format_type: 4 })
+      const gif = new Uint8Array([...Buffer.from('GIF89a'), 0, 0, 0, 0])
+
+      // The filename claims PNG; the bytes are a GIF. Discord answers a part
+      // whose type does not match its content with "Invalid Asset".
+      await client.createSticker('g1', { name: 'potato_02', tags: 'potato' }, gif, 'potato_02.png')
+
+      const form = fetchCalls[0].options?.body as FormData
+      expect((form.get('file') as File).type).toBe('image/gif')
+    })
+
+    it('createSticker refuses bytes that are not a supported format', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const junk = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])
+
+      await expect(
+        client.createSticker('g1', { name: 'potato_02', tags: 'potato' }, junk, 'potato_02.png'),
+      ).rejects.toThrow('not one of')
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('createSticker refuses a JPEG, which the sticker endpoint does not take', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const jpeg = new Uint8Array([0xff, 0xd8, 0xff, 0xe0, 0, 0, 0, 0])
+
+      await expect(
+        client.createSticker('g1', { name: 'potato_02', tags: 'potato' }, jpeg, 'potato_02.jpg'),
+      ).rejects.toThrow('File is a jpeg')
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('createEmoji refuses a JSON document, which the emoji endpoint does not take', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const json = new Uint8Array(Buffer.from('{"v":"5.5.7"}'))
+
+      await expect(client.createEmoji('g1', 'potato_01', json, 'potato_01.json')).rejects.toThrow('File is a json')
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('createSticker refuses JSON that is not a Lottie animation', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      const empty = new Uint8Array(Buffer.from('{}'))
+
+      await expect(
+        client.createSticker('g1', { name: 'potato_02', tags: 'potato' }, empty, 'potato_02.json'),
+      ).rejects.toThrow('not a Lottie animation')
+      expect(fetchCalls).toHaveLength(0)
+    })
+
+    it('deleteSticker issues a DELETE for the sticker', async () => {
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      mockResponse(null, 204)
+
+      await client.deleteSticker('g1', 's1')
+
+      expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/guilds/g1/stickers/s1')
+      expect(fetchCalls[0].options?.method).toBe('DELETE')
+    })
+  })
 })

package/src/platforms/discord/client.ts

@@ -1,10 +1,13 @@
 import { readFile } from 'node:fs/promises'
 
+import type { ExpressionFormat } from './expression-format'
+import { EMOJI_FORMATS, STICKER_FORMATS, lottieError, mediaTypeOf, sniffFormat } from './expression-format'
 import { getDiscordHeaders } from './super-properties'
 import { DiscordSearchIndexNotReadyResponseSchema, DiscordSearchResponseSchema } from './types'
 import type {
   DiscordChannel,
   DiscordDMChannel,
+  DiscordEmoji,
   DiscordFile,
   DiscordGuild,
   DiscordGuildMember,
@@ -16,6 +19,7 @@ import type {
   DiscordRole,
   DiscordSearchOptions,
   DiscordSearchResult,
+  DiscordSticker,
   DiscordUnreadDM,
   DiscordUnreadDMsResult,
   DiscordUnreadMention,
@@ -95,6 +99,7 @@ interface RateLimitBucket {
 }
 
 const BASE_URL = 'https://discord.com/api/v10'
+
 const MAX_RETRIES = 3
 const BASE_BACKOFF_MS = 100
 const MAX_SEARCH_INDEX_RETRY_MS = 30_000
@@ -384,6 +389,73 @@ export class DiscordClient {
     return files
   }
 
+  /**
+   * The media type the part declares comes from the bytes, never the filename,
+   * and only from the formats the target endpoint actually takes — a JPEG
+   * declared to the sticker endpoint is refused by Discord as "Invalid Asset".
+   */
+  private mediaTypeOrThrow(image: Uint8Array, allowed: ReadonlySet<ExpressionFormat>): string {
+    const format = sniffFormat(image)
+    if (!format || !allowed.has(format)) {
+      const names = [...allowed].join(', ')
+      throw new DiscordError(
+        format ? `File is a ${format}; this endpoint takes ${names}` : `File is not one of ${names}`,
+        'unsupported_asset',
+      )
+    }
+    if (format === 'json') {
+      const problem = lottieError(image)
+      if (problem) throw new DiscordError(problem, 'unsupported_asset')
+    }
+
+    return mediaTypeOf(format)
+  }
+
+  async listEmojis(guildId: string): Promise<DiscordEmoji[]> {
+    return this.request<DiscordEmoji[]>('GET', `/guilds/${guildId}/emojis`)
+  }
+
+  async createEmoji(
+    guildId: string,
+    name: string,
+    image: Uint8Array,
+    filename: string,
+    roles: string[] = [],
+  ): Promise<DiscordEmoji> {
+    return this.request<DiscordEmoji>('POST', `/guilds/${guildId}/emojis`, {
+      name,
+      image: `data:${this.mediaTypeOrThrow(image, EMOJI_FORMATS)};base64,${Buffer.from(image).toString('base64')}`,
+      roles,
+    })
+  }
+
+  async deleteEmoji(guildId: string, emojiId: string): Promise<void> {
+    await this.request<void>('DELETE', `/guilds/${guildId}/emojis/${emojiId}`)
+  }
+
+  async listStickers(guildId: string): Promise<DiscordSticker[]> {
+    return this.request<DiscordSticker[]>('GET', `/guilds/${guildId}/stickers`)
+  }
+
+  async createSticker(
+    guildId: string,
+    fields: { name: string; description?: string; tags: string },
+    image: Uint8Array,
+    filename: string,
+  ): Promise<DiscordSticker> {
+    const formData = new FormData()
+    formData.append('name', fields.name)
+    formData.append('description', fields.description ?? '')
+    formData.append('tags', fields.tags)
+    formData.append('file', new Blob([image], { type: this.mediaTypeOrThrow(image, STICKER_FORMATS) }), filename)
+
+    return this.requestFormData<DiscordSticker>(`/guilds/${guildId}/stickers`, formData)
+  }
+
+  async deleteSticker(guildId: string, stickerId: string): Promise<void> {
+    await this.request<void>('DELETE', `/guilds/${guildId}/stickers/${stickerId}`)
+  }
+
   async listDMChannels(): Promise<DiscordDMChannel[]> {
     return this.request<DiscordDMChannel[]>('GET', '/users/@me/channels')
   }

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))