agent-messenger 2.37.2 → 2.38.1

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

package/src/platforms/discord/expression-format.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'bun:test'
+
+import { EMOJI_FORMATS, STICKER_FORMATS, lottieError, mediaTypeOf, sniffFormat } from './expression-format'
+
+const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13])
+const gif = new Uint8Array([...Buffer.from('GIF89a'), 0, 0, 0, 0])
+const jpeg = new Uint8Array([0xff, 0xd8, 0xff, 0xe0, 0, 0, 0, 0])
+const webp = new Uint8Array([...Buffer.from('RIFF'), 0, 0, 0, 0, ...Buffer.from('WEBP')])
+const json = new Uint8Array(Buffer.from('  {"v":"5.5.7","fr":30}'))
+
+describe('sniffFormat', () => {
+  it('reads PNG from its signature', () => {
+    expect(sniffFormat(png)).toBe('png')
+  })
+
+  it('reads GIF, JPEG and WebP from their signatures', () => {
+    expect(sniffFormat(gif)).toBe('gif')
+    expect(sniffFormat(jpeg)).toBe('jpeg')
+    expect(sniffFormat(webp)).toBe('webp')
+  })
+
+  it('reads JSON from a leading brace — a Lottie is a JSON document', () => {
+    expect(sniffFormat(json)).toBe('json')
+  })
+
+  it('ignores the filename entirely — a GIF named .png is still a GIF', () => {
+    // Discord answers a part whose declared type does not match its bytes
+    // with a bare "Invalid Asset".
+    expect(sniffFormat(gif)).toBe('gif')
+  })
+
+  it('returns null for bytes that match no supported format', () => {
+    expect(sniffFormat(new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]))).toBeNull()
+  })
+
+  it('returns null for a truncated file', () => {
+    expect(sniffFormat(new Uint8Array([0x89, 0x50]))).toBeNull()
+  })
+
+  it('reads JSON past more leading whitespace than a fixed lookahead', () => {
+    const padded = new Uint8Array(Buffer.from(' '.repeat(40) + '{"v":"5.5.7"}'))
+    expect(sniffFormat(padded)).toBe('json')
+  })
+
+  it('does not mistake a long run of zero bytes for JSON', () => {
+    expect(sniffFormat(new Uint8Array(64))).toBeNull()
+  })
+})
+
+describe('endpoint format sets', () => {
+  it('emoji takes the still and animated image formats, not Lottie', () => {
+    expect([...EMOJI_FORMATS].sort()).toEqual(['gif', 'jpeg', 'png', 'webp'])
+  })
+
+  it('sticker takes PNG, GIF and JSON, not JPEG or WebP', () => {
+    // A JPEG sticker would otherwise be declared image/jpeg and refused by
+    // Discord as "Invalid Asset" — the rejection this check exists to avoid.
+    expect([...STICKER_FORMATS].sort()).toEqual(['gif', 'json', 'png'])
+  })
+})
+
+describe('mediaTypeOf', () => {
+  it('maps each format to the type Discord expects', () => {
+    expect(mediaTypeOf('png')).toBe('image/png')
+    expect(mediaTypeOf('gif')).toBe('image/gif')
+    expect(mediaTypeOf('jpeg')).toBe('image/jpeg')
+    expect(mediaTypeOf('webp')).toBe('image/webp')
+    expect(mediaTypeOf('json')).toBe('application/json')
+  })
+})
+
+describe('lottieError', () => {
+  const bytesOf = (text: string) => new Uint8Array(Buffer.from(text))
+
+  it('accepts a document with a layers array', () => {
+    expect(lottieError(bytesOf('{"v":"5.5.7","fr":30,"layers":[{"ty":4}]}'))).toBeNull()
+  })
+
+  it('accepts an animation with no layers yet', () => {
+    expect(lottieError(bytesOf('{"v":"5.5.7","layers":[]}'))).toBeNull()
+  })
+
+  it('rejects an empty object', () => {
+    // Discord answers `{}` uploaded as a sticker with a bare "Invalid Asset".
+    expect(lottieError(bytesOf('{}'))).toContain('layers')
+  })
+
+  it('rejects JSON that is not an animation', () => {
+    expect(lottieError(bytesOf('{"name":"package","version":"1.0.0"}'))).toContain('layers')
+  })
+
+  it('rejects a document whose layers is not an array', () => {
+    expect(lottieError(bytesOf('{"layers":"nope"}'))).toContain('layers')
+  })
+
+  it('rejects malformed JSON without throwing', () => {
+    expect(lottieError(bytesOf('{"layers":['))).toContain('valid JSON')
+  })
+
+  it('rejects a document carrying invalid UTF-8', () => {
+    // A lenient decoder turns the stray byte into U+FFFD, leaving JSON that
+    // parses and passes — and Discord then refuses it as "Invalid Asset".
+    const broken = new Uint8Array([...Buffer.from('{"layers":[],"nm":"'), 0xff, ...Buffer.from('"}')])
+    // The layers array is present, so the message must name the real fault.
+    expect(lottieError(broken)).toContain('UTF-8')
+  })
+})

package/src/platforms/discord/expression-format.ts

@@ -0,0 +1,117 @@
+/**
+ * Decide an expression's format from its bytes, not its filename.
+ *
+ * The upload declares a media type in its multipart part, and Discord answers
+ * a part whose declared type does not match its content with a bare
+ * "Invalid Asset" — the same opaque rejection a missing type produces. A
+ * filename is unverified input, so deriving the type from the extension means
+ * one mislabelled file in a batch fails without saying which, or why.
+ *
+ * A leading `{` proves only that the file is JSON, so a sticker's JSON is
+ * checked for the one field every Lottie animation carries. Uploading `{}`
+ * otherwise comes back as a bare "Invalid Asset". Whether the animation renders
+ * is still Discord's call, and Lottie needs a VERIFIED or PARTNERED guild.
+ *
+ * This deliberately does not check dimensions. Discord's documentation gives
+ * 320x320 for stickers, but a 408x408 PNG uploads and registers fine, so a
+ * local size check would refuse files the API accepts.
+ */
+
+export type ExpressionFormat = 'png' | 'gif' | 'jpeg' | 'webp' | 'json'
+
+/**
+ * The two endpoints do not take the same formats, so one shared set would let a
+ * JPEG reach the sticker endpoint — declared image/jpeg, and refused with the
+ * same opaque "Invalid Asset" this check exists to avoid.
+ */
+export const EMOJI_FORMATS: ReadonlySet<ExpressionFormat> = new Set(['png', 'gif', 'jpeg', 'webp'])
+/** APNG carries the PNG signature, so it is covered by 'png'. */
+export const STICKER_FORMATS: ReadonlySet<ExpressionFormat> = new Set(['png', 'gif', 'json'])
+
+const MEDIA_TYPES: Record<ExpressionFormat, string> = {
+  png: 'image/png',
+  gif: 'image/gif',
+  jpeg: 'image/jpeg',
+  webp: 'image/webp',
+  json: 'application/json',
+}
+
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
+const JPEG_SIGNATURE = [0xff, 0xd8, 0xff]
+
+function startsWith(bytes: Uint8Array, signature: number[]): boolean {
+  return bytes.length >= signature.length && signature.every((byte, index) => bytes[index] === byte)
+}
+
+function ascii(bytes: Uint8Array, start: number, length: number): string {
+  return String.fromCharCode(...bytes.subarray(start, start + length))
+}
+
+export function mediaTypeOf(format: ExpressionFormat): string {
+  return MEDIA_TYPES[format]
+}
+
+export function sniffFormat(bytes: Uint8Array): ExpressionFormat | null {
+  // APNG carries the PNG signature too; Discord takes both as image/png.
+  if (startsWith(bytes, PNG_SIGNATURE)) return 'png'
+  if (startsWith(bytes, JPEG_SIGNATURE)) return 'jpeg'
+
+  if (bytes.length >= 6 && ascii(bytes, 0, 3) === 'GIF') {
+    const version = ascii(bytes, 3, 3)
+    if (version === '87a' || version === '89a') return 'gif'
+  }
+
+  if (bytes.length >= 12 && ascii(bytes, 0, 4) === 'RIFF' && ascii(bytes, 8, 4) === 'WEBP') {
+    return 'webp'
+  }
+
+  // Lottie is a JSON document. Scan past leading whitespace and a BOM until the
+  // first byte that is neither — a fixed lookahead would reject a file that is
+  // merely indented. Any binary hits a non-skippable byte almost immediately.
+  for (const byte of bytes) {
+    if (byte === 0x7b) return 'json'
+    const skippable =
+      byte === 0x20 ||
+      byte === 0x09 ||
+      byte === 0x0a ||
+      byte === 0x0d ||
+      byte === 0xef ||
+      byte === 0xbb ||
+      byte === 0xbf
+    if (!skippable) break
+  }
+
+  return null
+}
+
+/**
+ * A Lottie animation always carries a `layers` array. Checking that one field
+ * rejects an arbitrary JSON document without guessing at the rest of the
+ * schema, which would risk refusing animations a newer exporter produces.
+ *
+ * Returns the reason the document cannot be one, or null when it may be. The
+ * two faults are reported apart: a file can hold a layers array and still be
+ * broken, and "no layers array" would send its author looking in the wrong
+ * place.
+ */
+export function lottieError(bytes: Uint8Array): string | null {
+  let text: string
+  try {
+    // A lenient decoder substitutes U+FFFD for a malformed byte, leaving JSON
+    // that parses while the file itself is not valid UTF-8.
+    text = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+  } catch {
+    return 'JSON file is not valid UTF-8'
+  }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(text)
+  } catch {
+    return 'JSON file is not valid JSON'
+  }
+
+  const hasLayers =
+    typeof parsed === 'object' && parsed !== null && Array.isArray((parsed as { layers?: unknown }).layers)
+  return hasLayers ? null : 'JSON file is not a Lottie animation (no layers array)'
+}

package/src/platforms/discord/expression-names.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'bun:test'
+
+import { validateEmojiName, validateStickerName } from './expression-names'
+
+describe('validateEmojiName', () => {
+  it('accepts letters, digits and underscores', () => {
+    expect(validateEmojiName('potato_13')).toBeNull()
+  })
+
+  it('rejects a hyphen, naming the allowed characters', () => {
+    // A filename like potato-13.png derives this name, and Discord answers
+    // "Invalid Form Body" without saying which field was at fault.
+    expect(validateEmojiName('potato-13')).toContain('letters, digits, underscores')
+  })
+
+  it('rejects a space', () => {
+    expect(validateEmojiName('potato 13')).toContain('letters, digits, underscores')
+  })
+
+  it('rejects a name shorter than 2 characters', () => {
+    expect(validateEmojiName('a')).toContain('2')
+  })
+
+  it('rejects a name longer than 32 characters', () => {
+    expect(validateEmojiName('p'.repeat(33))).toContain('32')
+  })
+})
+
+describe('validateStickerName', () => {
+  it('accepts a two-character name', () => {
+    expect(validateStickerName('빼액')).toBeNull()
+  })
+
+  it('rejects a single character, naming the minimum', () => {
+    expect(validateStickerName('흥')).toContain('2')
+  })
+
+  it('rejects a name longer than 30 characters', () => {
+    expect(validateStickerName('가'.repeat(31))).toContain('30')
+  })
+})

package/src/platforms/discord/expression-names.ts

@@ -0,0 +1,36 @@
+/**
+ * Discord answers an out-of-range expression name with a bare
+ * "Invalid Form Body", naming neither the field nor the file. In a batch
+ * upload that says nothing about which one was refused, so the name — the one
+ * part of an expression the caller supplies directly — is checked first.
+ */
+
+const EMOJI_NAME_PATTERN = /^[A-Za-z0-9_]+$/
+const EMOJI_NAME_MIN = 2
+const EMOJI_NAME_MAX = 32
+
+const STICKER_NAME_MIN = 2
+const STICKER_NAME_MAX = 30
+
+export function validateEmojiName(name: string): string | null {
+  if (name.length < EMOJI_NAME_MIN) {
+    return `Emoji name must be at least ${EMOJI_NAME_MIN} characters: "${name}"`
+  }
+  if (name.length > EMOJI_NAME_MAX) {
+    return `Emoji name must be at most ${EMOJI_NAME_MAX} characters: "${name}"`
+  }
+  if (!EMOJI_NAME_PATTERN.test(name)) {
+    return `Emoji name may only contain letters, digits, underscores: "${name}"`
+  }
+  return null
+}
+
+export function validateStickerName(name: string): string | null {
+  if (name.length < STICKER_NAME_MIN) {
+    return `Sticker name must be at least ${STICKER_NAME_MIN} characters: "${name}"`
+  }
+  if (name.length > STICKER_NAME_MAX) {
+    return `Sticker name must be at most ${STICKER_NAME_MAX} characters: "${name}"`
+  }
+  return null
+}

package/src/platforms/discord/index.ts

@@ -8,6 +8,7 @@ export type {
   DiscordConfig,
   DiscordCredentials,
   DiscordDMChannel,
+  DiscordEmoji,
   DiscordFile,
   DiscordGatewayChannelEvent,
   DiscordGatewayEvent,
@@ -28,6 +29,7 @@ export type {
   DiscordReadState,
   DiscordReadStateSnapshot,
   DiscordRelationship,
+  DiscordSticker,
   DiscordRole,
   DiscordRoleColors,
   DiscordRoleTags,

package/src/platforms/discord/types.ts

@@ -8,7 +8,14 @@ export interface DiscordGuild {
   id: string
   name: string
   icon?: string
+  /** Only present on GET /users/@me/guilds. */
   owner?: boolean
+  /** Only present on GET /guilds/{id}. */
+  owner_id?: string
+  premium_tier?: number
+  premium_subscription_count?: number
+  emojis?: DiscordEmoji[]
+  stickers?: DiscordSticker[]
 }
 
 export interface DiscordChannel {
@@ -116,6 +123,30 @@ export interface DiscordFile {
   width?: number
 }
 
+export interface DiscordEmoji {
+  id: string
+  name: string
+  animated?: boolean
+  managed?: boolean
+  available?: boolean
+  roles?: string[]
+  user?: DiscordUser
+}
+
+export interface DiscordSticker {
+  id: string
+  name: string
+  description?: string | null
+  tags: string
+  /** STANDARD = 1, GUILD = 2. */
+  type: number
+  /** PNG = 1, APNG = 2, LOTTIE = 3, GIF = 4. */
+  format_type: number
+  available?: boolean
+  guild_id?: string
+  user?: DiscordUser
+}
+
 export interface DiscordMention {
   id: string
   channel_id: string