@kyyinfinite/lumina 1.0.2 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyyinfinite/lumina",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "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/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/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/media/video.js

@@ -1,9 +1,4 @@
- *
- *
- *
-
 import { PassThrough, Readable } from 'node:stream'
-
 import { MediaError } from '../errors.js'
 import { resize } from './image.js'
 
@@ -16,7 +11,7 @@ async function loadFfmpeg() {
         return (await import('fluent-ffmpeg')).default
       } catch (err) {
         throw new MediaError(
-          "fluent-ffmpeg is not installed. Install it with `npm i fluent-ffmpeg` (and ffmpeg itself) to use video thumbnails.",
+          'fluent-ffmpeg is not installed. Run: npm i fluent-ffmpeg',
           { code: 'LUMINA_MEDIA_FFMPEG_MISSING', cause: err },
         )
       }
@@ -25,8 +20,6 @@ async function loadFfmpeg() {
   return ffmpegPromise
 }
 
- *
- *
 export function getMp4Duration(buffer, opts = {}) {
   const { silent = true } = opts
 
@@ -36,16 +29,12 @@ export function getMp4Duration(buffer, opts = {}) {
   }
 
   try {
-    if (!Buffer.isBuffer(buffer) || buffer.length < 8) {
-      return fail('invalid buffer: too short')
-    }
+    if (!Buffer.isBuffer(buffer) || buffer.length < 8) return fail('invalid buffer: too short')
 
     let offset = 0
     while (offset < buffer.length - 8) {
       const size = buffer.readUInt32BE(offset)
-      if (size < 8 || offset + size > buffer.length) {
-        return fail('invalid atom size')
-      }
+      if (size < 8 || offset + size > buffer.length) return fail('invalid atom size')
 
       const type = buffer.toString('ascii', offset + 4, offset + 8)
       if (type === 'moov') {
@@ -53,9 +42,7 @@ export function getMp4Duration(buffer, opts = {}) {
         const moovEnd = offset + size
         while (moovOffset < moovEnd - 8) {
           const childSize = buffer.readUInt32BE(moovOffset)
-          if (childSize < 8 || moovOffset + childSize > moovEnd) {
-            return fail('invalid child atom size')
-          }
+          if (childSize < 8 || moovOffset + childSize > moovEnd) return fail('invalid child atom size')
           const childType = buffer.toString('ascii', moovOffset + 4, moovOffset + 8)
           if (childType === 'mvhd') {
             const version = buffer.readUInt8(moovOffset + 8)
@@ -87,8 +74,6 @@ export function getMp4Duration(buffer, opts = {}) {
   }
 }
 
-
- *
 export async function extractThumbnail(videoBuffer, opts = {}) {
   const {
     time,
@@ -105,10 +90,14 @@ export async function extractThumbnail(videoBuffer, opts = {}) {
   return new Promise((resolve, reject) => {
     const fail = (err) => {
       if (silent) return resolve(result === 'base64' ? '' : Buffer.alloc(0))
-      reject(err instanceof MediaError ? err : new MediaError(err?.message ?? String(err), {
-        code: 'LUMINA_MEDIA_FFMPEG_FAILED',
-        cause: err,
-      }))
+      reject(
+        err instanceof MediaError
+          ? err
+          : new MediaError(err?.message ?? String(err), {
+              code: 'LUMINA_MEDIA_FFMPEG_FAILED',
+              cause: err,
+            }),
+      )
     }
 
     if (!Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
@@ -130,9 +119,7 @@ export async function extractThumbnail(videoBuffer, opts = {}) {
         if (frame.length === 0) {
           return fail(new MediaError('ffmpeg produced empty output', { code: 'LUMINA_MEDIA_FFMPEG_EMPTY' }))
         }
-        if (resizeOutput) {
-          frame = await resize(frame, { width, height, fit: 'cover', format })
-        }
+        if (resizeOutput) frame = await resize(frame, { width, height, fit: 'cover', format })
         resolve(result === 'base64' ? frame.toString('base64') : frame)
       } catch (err) {
         fail(err)
@@ -143,10 +130,12 @@ export async function extractThumbnail(videoBuffer, opts = {}) {
     try {
       ffmpeg(input)
         .outputOptions([`-ss ${seekTime}`, '-vframes 1', '-vcodec png', '-f image2pipe'])
-        .on('error', (err) => fail(new MediaError(`ffmpeg error: ${err.message}`, {
-          code: 'LUMINA_MEDIA_FFMPEG_FAILED',
-          cause: err,
-        })))
+        .on('error', (err) =>
+          fail(new MediaError(`ffmpeg error: ${err.message}`, {
+            code: 'LUMINA_MEDIA_FFMPEG_FAILED',
+            cause: err,
+          })),
+        )
         .pipe(output, { end: true })
     } catch (err) {
       fail(err)

package/src/parsers/code-tokenizer-keywords.js

@@ -1,5 +1,3 @@
- *
- *
 
 export const KEYWORDS = {
   javascript: new Set([

package/src/parsers/code-tokenizer.js

@@ -1,6 +1,3 @@
- *
- *
- *
 
 import { HighlightType, HighlightLabel } from '../proto/enums.js'
 import { KEYWORDS, SLASH_COMMENT_LANGS, HASH_COMMENT_LANGS, BLOCK_COMMENT_LANGS } from './code-tokenizer-keywords.js'
@@ -17,7 +14,6 @@ function identifierChar(lang) {
   }
 }
 
- *
 export function tokenizeCode(code, lang = 'javascript') {
   if (typeof code !== 'string' || code.length === 0) {
     return { codeBlock: [], unifiedBlocks: [] }

package/src/proto/updater.js

@@ -1,7 +1,3 @@
- *
- *
- *
- *
 
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
@@ -47,7 +43,6 @@ const RE_CONST_REQUIRE =
 const RE_DESTRUCT_REQUIRE =
   /(?:const|let|var)\s*\{([^}]+)\}\s*=\s*require\(\s*(['"])([^'"]+)\2\s*\)/g
 
- *
 export function transformToESM(src) {
   let out = src
   out = out.replace(RE_CONST_REQUIRE, (_, name, _q, mod) => `import ${name} from '${mod}'`)
@@ -67,7 +62,6 @@ export function transformToESM(src) {
   return out
 }
 
- *
 export function applyKnownFixes(filename, content) {
   const applied = []
   let next = content
@@ -100,7 +94,6 @@ export class ProtoUpdater {
     }
   }
 
-   *
   async #listJsFiles(dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true })
     const out = []
@@ -112,7 +105,6 @@ export class ProtoUpdater {
     return out
   }
 
-   *
   async backup() {
     await fs.mkdir(this.backupDir, { recursive: true })
     const timestamp = Date.now()
@@ -127,7 +119,6 @@ export class ProtoUpdater {
     return record
   }
 
-   *
   async #hashTree(dir) {
     const files = (await this.#listJsFiles(dir)).sort()
     const hashes = await Promise.all(
@@ -139,7 +130,6 @@ export class ProtoUpdater {
     return sha256(hashes.join('\n'))
   }
 
-   *
   async restore(id) {
     const record = this.history.find((h) => h.id === id)
     if (!record) {
@@ -160,7 +150,6 @@ export class ProtoUpdater {
     await this.restore(last.id)
   }
 
-   *
   async validate() {
     const files = await this.#listJsFiles(this.protoPath)
     const errors = []
@@ -176,7 +165,6 @@ export class ProtoUpdater {
     return { ok: errors.length === 0, errors }
   }
 
-   *
   async update(opts = {}) {
     const autoRollback = opts.autoRollback ?? true
     const dryRun = opts.dryRun ?? false