@kyyinfinite/lumina 1.0.1 → 1.0.4

package/README.md

@@ -360,6 +360,88 @@ Type-checked features:
 - Enum-like catalogs (`MessageType`, `HeaderType`, `LayoutKind`, ...) are `Readonly`
 - `Bot.raw` escape hatch typed as `WASocket`
 
+
+---
+
+## Baileys Compatibility
+
+Lumina is not tied to a specific Baileys version or fork. When `new Bot(sock)` is called, Lumina automatically detects the available Baileys package in your project.
+
+### Auto-Detect (default)
+
+No configuration is required. Lumina tries the following packages in order and uses the first one that can be successfully imported:
+
+```
+@kyyinfinite/baileys
+@whiskeysockets/baileys
+baileys
+@adiwajshing/baileys
+@brunocgc/baileys
+@open-wa/baileys
+```
+
+```js
+// Lumina automatically detects @kyyinfinite/baileys (or any installed fork)
+const bot = new Bot(sock)
+```
+
+---
+
+### Explicit Package Name
+
+If you're using a custom-named fork, specify it with `baileysPackage`:
+
+```js
+const bot = new Bot(sock, {
+  baileysPackage: '@namafork/baileys',
+})
+```
+
+---
+
+### Module Injection
+
+The fastest option — zero dynamic imports. Simply inject the module directly:
+
+```js
+import * as baileys from '@kyyinfinite/baileys'
+
+const bot = new Bot(sock, {
+  baileys,
+})
+```
+
+This is ideal if you've already imported Baileys elsewhere and want to avoid duplicate imports.
+
+---
+
+### Socket Fallback
+
+If no Baileys package is found, Lumina falls back to its internal socket-based implementation. Core features (text, buttons, carousel, stickers) continue to work. Media uploads require `sock.waUploadToServer` to be available.
+
+---
+
+### Debug: Check the Active Adapter
+
+```js
+const bot = new Bot(sock)
+console.log(await bot.connection.adapterSource())
+// → '@kyyinfinite/baileys'
+// → '@whiskeysockets/baileys'
+// → 'injected-module'
+// → 'socket-fallback'
+```
+
+---
+
+### Summary
+
+| Option | When to use |
+|---|---|
+| _(not set)_ | Auto-detect. Recommended for most use cases. |
+| `baileysPackage: 'name'` | For custom forks that are not included in the auto-detect list. |
+| `baileys: module` | Manual module injection for the best performance. |
+
 ---
 
 ## API Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyyinfinite/lumina",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "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/baileys-adapter.js

@@ -0,0 +1,140 @@
+import crypto from 'node:crypto'
+import { ConnectionError } from '../errors.js'
+
+const KNOWN_PACKAGES = [
+  '@kyyinfinite/baileys',
+  '@whiskeysockets/baileys',
+  'baileys',
+  '@adiwajshing/baileys',
+  '@brunocgc/baileys',
+  '@open-wa/baileys',
+]
+
+const REQUIRED_FNS = [
+  'prepareWAMessageMedia',
+  'generateWAMessageFromContent',
+  'generatePollMessage',
+  'generateReactionMessage',
+]
+
+function extractFns(mod) {
+  const missing = REQUIRED_FNS.filter((fn) => typeof mod[fn] !== 'function')
+  if (missing.length > 0) return null
+  return {
+    prepareWAMessageMedia: mod.prepareWAMessageMedia,
+    generateWAMessageFromContent: mod.generateWAMessageFromContent,
+    generatePollMessage: mod.generatePollMessage,
+    generateReactionMessage: mod.generateReactionMessage,
+  }
+}
+
+function makeFallbackFns(socket) {
+  const generateId = () => crypto.randomBytes(8).toString('hex').toUpperCase()
+
+  const generateWAMessageFromContent = (jid, content, opts = {}) => ({
+    key: {
+      remoteJid: jid,
+      fromMe: true,
+      id: opts.messageId ?? generateId(),
+      participant: opts.participant,
+    },
+    message: content,
+    messageTimestamp: Math.floor(Date.now() / 1000),
+    status: 1,
+  })
+
+  const generatePollMessage = async (jid, opts) => {
+    const msg = await socket.sendMessage(jid, {
+      poll: {
+        name: opts.name,
+        values: opts.values,
+        selectableCount: opts.selectableCount ?? 1,
+      },
+    })
+    return msg
+  }
+
+  const generateReactionMessage = (jid, opts) =>
+    generateWAMessageFromContent(jid, {
+      reactionMessage: { key: opts.key, text: opts.text },
+    })
+
+  const prepareWAMessageMedia = async (media, opts = {}) => {
+    if (!socket.waUploadToServer) {
+      throw new ConnectionError(
+        'Cannot upload media: no baileys package found and socket.waUploadToServer is unavailable',
+        { code: 'LUMINA_ADAPTER_NO_UPLOAD' },
+      )
+    }
+    const [type, source] = Object.entries(media)[0]
+    const uploaded = await socket.waUploadToServer(
+      Buffer.isBuffer(source) ? source : source,
+      { mediaType: type, jid: opts.jid },
+    )
+    return { [type]: { url: uploaded.url, ...uploaded } }
+  }
+
+  return { generateWAMessageFromContent, generatePollMessage, generateReactionMessage, prepareWAMessageMedia }
+}
+
+export class BaileysAdapter {
+  #fns = null
+  #source = 'unknown'
+
+  static async resolve(socket, opts = {}) {
+    const adapter = new BaileysAdapter()
+
+    if (opts.baileys && typeof opts.baileys === 'object') {
+      const fns = extractFns(opts.baileys)
+      if (fns) {
+        adapter.#fns = fns
+        adapter.#source = 'injected-module'
+        return adapter
+      }
+    }
+
+    if (typeof opts.baileysPackage === 'string') {
+      try {
+        const mod = await import(opts.baileysPackage)
+        const fns = extractFns(mod)
+        if (fns) {
+          adapter.#fns = fns
+          adapter.#source = opts.baileysPackage
+          return adapter
+        }
+      } catch {
+        throw new ConnectionError(
+          `baileysPackage "${opts.baileysPackage}" could not be imported or is missing required functions`,
+          { code: 'LUMINA_ADAPTER_PACKAGE_NOT_FOUND' },
+        )
+      }
+    }
+
+    for (const pkg of KNOWN_PACKAGES) {
+      try {
+        const mod = await import(pkg)
+        const fns = extractFns(mod)
+        if (fns) {
+          adapter.#fns = fns
+          adapter.#source = pkg
+          return adapter
+        }
+      } catch {}
+    }
+
+    adapter.#fns = makeFallbackFns(socket)
+    adapter.#source = 'socket-fallback'
+    return adapter
+  }
+
+  get source() {
+    return this.#source
+  }
+
+  get prepareWAMessageMedia() { return this.#fns.prepareWAMessageMedia }
+  get generateWAMessageFromContent() { return this.#fns.generateWAMessageFromContent }
+  get generatePollMessage() { return this.#fns.generatePollMessage }
+  get generateReactionMessage() { return this.#fns.generateReactionMessage }
+}
+
+export default BaileysAdapter

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/client/connection.js

@@ -1,11 +1,12 @@
 import { ConnectionError } from '../errors.js'
+import { BaileysAdapter } from './baileys-adapter.js'
 
 export class Connection {
+  #socket = null
+  #adapter = null
+
   constructor(socket, opts = {}) {
     if (!socket) throw new ConnectionError('socket is required', { code: 'LUMINA_CONNECTION_NO_SOCKET' })
-    this.#socket = socket
-    this.uploadJid = opts.uploadJid
-    this.logger = opts.logger
 
     const required = ['relayMessage', 'ev']
     for (const m of required) {
@@ -15,34 +16,46 @@ export class Connection {
         })
       }
     }
+
+    this.#socket = socket
+    this.uploadJid = opts.uploadJid
+    this.logger = opts.logger
+    this.#adapter = BaileysAdapter.resolve(socket, opts)
   }
 
-  #socket = null
+  async #fn() {
+    if (this.#adapter instanceof Promise) this.#adapter = await this.#adapter
+    return this.#adapter
+  }
 
   async uploadMedia(media, opts = {}) {
-    const { prepareWAMessageMedia } = await import('@whiskeysockets/baileys')
+    const adapter = await this.#fn()
     const jid = opts.jid ?? this.uploadJid
     if (!jid) {
       throw new ConnectionError('uploadJid must be set (via constructor or per-call)', {
         code: 'LUMINA_CONNECTION_NO_UPLOAD_JID',
       })
     }
-    return prepareWAMessageMedia(media, { upload: this.#socket.waUploadToServer, jid, ...opts })
+    return adapter.prepareWAMessageMedia(media, {
+      upload: this.#socket.waUploadToServer,
+      jid,
+      ...opts,
+    })
   }
 
   async generateMessage(jid, content, opts = {}) {
-    const { generateWAMessageFromContent } = await import('@whiskeysockets/baileys')
-    return generateWAMessageFromContent(jid, content, opts)
+    const adapter = await this.#fn()
+    return adapter.generateWAMessageFromContent(jid, content, opts)
   }
 
   async generatePoll(jid, opts) {
-    const { generatePollMessage } = await import('@whiskeysockets/baileys')
-    return generatePollMessage(jid, opts)
+    const adapter = await this.#fn()
+    return adapter.generatePollMessage(jid, opts)
   }
 
   async generateReaction(jid, opts) {
-    const { generateReactionMessage } = await import('@whiskeysockets/baileys')
-    return generateReactionMessage(jid, opts)
+    const adapter = await this.#fn()
+    return adapter.generateReactionMessage(jid, opts)
   }
 
   async relayMessage(jid, message, opts = {}) {
@@ -65,8 +78,11 @@ export class Connection {
     this.#socket.ev.off(event, handler)
   }
 
-  get raw() {
-    return this.#socket
+  get raw() { return this.#socket }
+
+  async adapterSource() {
+    const adapter = await this.#fn()
+    return adapter.source
   }
 }
 

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 }