@kyyinfinite/lumina 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyyinfinite/lumina",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Lumina — Modern WhatsApp framework built on top of Baileys. Hide the protocol complexity, expose a fluent API.",
   "type": "module",
   "main": "./src/index.js",

package/src/builders/index.js

@@ -3,4 +3,5 @@ export { ButtonV2Builder } from './button-v2.js'
 export { CarouselBuilder } from './carousel.js'
 export { CardBuilder } from './card.js'
 export { AIRichBuilder } from './ai-rich.js'
+export { StickerBuilder } from './sticker.js'
 export { applyContentFields, readContentFields } from './base.js'

package/src/builders/sticker.js

@@ -0,0 +1,102 @@
+import { toSticker, addExif } from '../media/sticker.js'
+import { fetchBuffer } from '../media/fetch.js'
+import { sniffMime, mimeToCategory } from '../utils/mime.js'
+import { coerceMediaSource } from '../utils/validator.js'
+import { createInteractiveNodes } from '../proto/relay-nodes.js'
+
+export class StickerBuilder {
+  constructor(conn) {
+    this.#conn = conn
+    this._source = null
+    this._type = null
+    this._packname = 'Lumina'
+    this._author = ''
+    this._categories = ['']
+    this._extra = {}
+  }
+
+  #conn
+
+  source(input) {
+    this._source = input
+    return this
+  }
+
+  pack(packname, author = '') {
+    this._packname = packname
+    this._author = author
+    return this
+  }
+
+  author(author) {
+    this._author = author
+    return this
+  }
+
+  emoji(...emojis) {
+    this._categories = emojis.flat()
+    return this
+  }
+
+  type(type) {
+    this._type = type
+    return this
+  }
+
+  extra(obj) {
+    Object.assign(this._extra, obj)
+    return this
+  }
+
+  #metadata() {
+    return {
+      packname: this._packname,
+      author: this._author,
+      categories: this._categories,
+      extra: this._extra,
+    }
+  }
+
+  async #resolveBuffer() {
+    if (!this._source) throw new Error('sticker source is required — call .source(buffer|url)')
+
+    let buffer
+
+    if (Buffer.isBuffer(this._source)) {
+      buffer = this._source
+    } else if (typeof this._source === 'string') {
+      buffer = await fetchBuffer(this._source)
+    } else {
+      const { raw } = coerceMediaSource(this._source)
+      buffer = Buffer.isBuffer(raw) ? raw : await fetchBuffer(raw.url)
+    }
+
+    return buffer
+  }
+
+  #detectType(buffer) {
+    if (this._type) return this._type
+    const mime = sniffMime(buffer)
+    const cat = mimeToCategory(mime)
+    if (cat === 'video') return 'video'
+    return 'image'
+  }
+
+  async build() {
+    const buffer = await this.#resolveBuffer()
+    const type = this.#detectType(buffer)
+    return toSticker(buffer, type, this.#metadata())
+  }
+
+  async send(jid, opts = {}) {
+    const stickerBuffer = await this.build()
+    const msg = await this.#conn.generateMessage(jid, { sticker: stickerBuffer }, opts)
+    await this.#conn.relayMessage(msg.key.remoteJid, msg.message, {
+      messageId: msg.key.id,
+      ...opts,
+    })
+    return msg
+  }
+}
+
+export default StickerBuilder

package/src/client/bot.js

@@ -6,6 +6,7 @@ import { ButtonBuilder } from '../builders/button.js'
 import { ButtonV2Builder } from '../builders/button-v2.js'
 import { CarouselBuilder } from '../builders/carousel.js'
 import { AIRichBuilder } from '../builders/ai-rich.js'
+import { StickerBuilder } from '../builders/sticker.js'
 import { extractInlineEntities, tokenizeCode, toTableMetadata } from '../parsers/index.js'
 import { createLogger } from '../utils/logger.js'
 
@@ -50,6 +51,11 @@ export class Bot {
   buttonV2() { return new ButtonV2Builder(this.connection) }
   carousel() { return new CarouselBuilder(this.connection, this.proto, this.media) }
   ai() { return new AIRichBuilder(this.connection, this.proto, this.media) }
+  sticker() { return new StickerBuilder(this.connection) }
+
+  async sendSticker(jid, source, opts = {}) {
+    return this.sticker().source(source).pack(opts.packname, opts.author).emoji(...(opts.categories ?? [''])).send(jid, opts)
+  }
 
   on(event, handler) { return this.connection.on(event, handler) }
   once(event, handler) { return this.connection.once(event, handler) }

package/src/index.js

@@ -5,6 +5,8 @@ import { ButtonV2Builder } from './builders/button-v2.js'
 import { CarouselBuilder } from './builders/carousel.js'
 import { CardBuilder } from './builders/card.js'
 import { AIRichBuilder } from './builders/ai-rich.js'
+import { StickerBuilder } from './builders/sticker.js'
+import { toSticker, addExif } from './media/sticker.js'
 import { MediaService } from './services/media-service.js'
 import { ProtoService } from './services/proto-service.js'
 import { MessageService } from './services/message-service.js'
@@ -32,7 +34,8 @@ export const VERSION = '1.0.0'
 
 export {
   Bot, Connection,
-  ButtonBuilder, ButtonV2Builder, CarouselBuilder, CardBuilder, AIRichBuilder,
+  ButtonBuilder, ButtonV2Builder, CarouselBuilder, CardBuilder, AIRichBuilder, StickerBuilder,
+  toSticker, addExif,
   MediaService, ProtoService, MessageService,
   extractInlineEntities, tokenizeCode, toTableMetadata,
   ProtoUpdater, transformToESM, applyKnownFixes,

package/src/media/sticker.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs'
+import { tmpdir } from 'node:os'
+import crypto from 'node:crypto'
+import path from 'node:path'
+import { MediaError } from '../errors.js'
+
+function tmpPath(ext) {
+  return path.join(tmpdir(), `${crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.${ext}`)
+}
+
+function cleanup(...files) {
+  for (const f of files) {
+    try { fs.unlinkSync(f) } catch {}
+  }
+}
+
+async function loadFfmpeg() {
+  try {
+    const { default: ffmpeg } = await import('fluent-ffmpeg')
+    return ffmpeg
+  } catch {
+    throw new MediaError('fluent-ffmpeg is not installed. Run: npm i fluent-ffmpeg', {
+      code: 'LUMINA_STICKER_NO_FFMPEG',
+    })
+  }
+}
+
+async function loadWebp() {
+  try {
+    const { default: webp } = await import('node-webpmux')
+    return webp
+  } catch {
+    throw new MediaError('node-webpmux is not installed. Run: npm i node-webpmux', {
+      code: 'LUMINA_STICKER_NO_WEBPMUX',
+    })
+  }
+}
+
+const FFMPEG_IMAGE_OPTS = [
+  '-vcodec', 'libwebp',
+  '-vf', "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15,pad=320:320:-1:-1:color=white@0.0,split[a][b];[a]palettegen=reserve_transparent=on:transparency_color=ffffff[p];[b][p]paletteuse",
+]
+
+const FFMPEG_VIDEO_OPTS = [
+  '-vcodec', 'libwebp',
+  '-vf', "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15,pad=320:320:-1:-1:color=white@0.0,split[a][b];[a]palettegen=reserve_transparent=on:transparency_color=ffffff[p];[b][p]paletteuse",
+  '-loop', '0',
+  '-ss', '00:00:00',
+  '-t', '00:00:05',
+  '-preset', 'default',
+  '-an',
+  '-vsync', '0',
+]
+
+async function convertToWebp(buffer, type) {
+  const ffmpeg = await loadFfmpeg()
+  const inExt = type === 'video' ? 'mp4' : 'jpg'
+  const inFile = tmpPath(inExt)
+  const outFile = tmpPath('webp')
+
+  fs.writeFileSync(inFile, buffer)
+
+  await new Promise((resolve, reject) => {
+    ffmpeg(inFile)
+      .on('error', reject)
+      .on('end', () => resolve())
+      .addOutputOptions(type === 'video' ? FFMPEG_VIDEO_OPTS : FFMPEG_IMAGE_OPTS)
+      .toFormat('webp')
+      .save(outFile)
+  })
+
+  const result = fs.readFileSync(outFile)
+  cleanup(inFile, outFile)
+  return result
+}
+
+function buildExif(metadata) {
+  const json = {
+    'sticker-pack-id': crypto.randomBytes(32).toString('hex'),
+    'sticker-pack-name': metadata.packname ?? 'Lumina',
+    'sticker-pack-publisher': metadata.author ?? '',
+    'emojis': metadata.categories ?? [''],
+    ...metadata.extra,
+  }
+
+  const attr = Buffer.from([
+    0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  ])
+  const jsonBuf = Buffer.from(JSON.stringify(json), 'utf8')
+  const exif = Buffer.concat([attr, jsonBuf])
+  exif.writeUIntLE(jsonBuf.length, 14, 4)
+  return exif
+}
+
+async function injectExif(webpBuffer, metadata) {
+  const webp = await loadWebp()
+  const img = new webp.Image()
+  await img.load(webpBuffer)
+  img.exif = buildExif(metadata)
+  return img.save(null)
+}
+
+export async function toSticker(buffer, type = 'image', metadata = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    throw new MediaError('toSticker() requires a non-empty Buffer', { code: 'LUMINA_STICKER_EMPTY' })
+  }
+  if (!['image', 'video'].includes(type)) {
+    throw new MediaError(`type must be image or video, got: ${type}`, { code: 'LUMINA_STICKER_BAD_TYPE' })
+  }
+
+  const webp = await convertToWebp(buffer, type)
+  return injectExif(webp, metadata)
+}
+
+export async function addExif(webpBuffer, metadata = {}) {
+  if (!Buffer.isBuffer(webpBuffer) || webpBuffer.length === 0) {
+    throw new MediaError('addExif() requires a non-empty Buffer', { code: 'LUMINA_STICKER_EMPTY' })
+  }
+  return injectExif(webpBuffer, metadata)
+}
+
+export default { toSticker, addExif }