@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/group-operation-guard.js

@@ -0,0 +1,147 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.GroupOperationGuard =
+    exports.extractPrivacyBlock =
+    exports.classifyGroupOpError =
+    exports.GROUP_OP_ERRORS =
+        void 0
+
+/**
+ * @file group-operation-guard.js
+ * @description Rate limiting for WhatsApp group operations.
+ *   Prevents account_reachout_restricted and rate-overlimit errors
+ *   by enforcing per-operation windows on group adds, removes, and creates.
+ *
+ *   WA unofficial limits (observed):
+ *     - groupParticipantsUpdate (add): ~3 new contacts per 10 min
+ *     - groupCreate: ~2 per 10 min
+ *     - Rapid retries after 403: triggers account_reachout_restricted
+ *
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), original by baileys-antiban contributors
+ */
+
+const DEFAULT_LIMITS = {
+    add: { max: 3, windowMs: 10 * 60 * 1000 }, // 3 adds / 10 min
+    remove: { max: 5, windowMs: 10 * 60 * 1000 }, // 5 removes / 10 min
+    create: { max: 2, windowMs: 10 * 60 * 1000 }, // 2 creates / 10 min
+    invite: { max: 10, windowMs: 10 * 60 * 1000 } // 10 invite fetches / 10 min
+}
+
+/** Known WA error patterns for group operations */
+const GROUP_OP_ERRORS = {
+    REACHOUT_RESTRICTED: 'account_reachout_restricted',
+    RATE_OVERLIMIT: 'rate-overlimit',
+    PRIVACY_BLOCK: '403',
+    INVITE_EXPIRED: 'gone',
+    GROUP_LOCKED: 'locked'
+}
+exports.GROUP_OP_ERRORS = GROUP_OP_ERRORS
+
+/**
+ * Classify a caught error from a group operation.
+ * @param {unknown} err
+ * @returns {string|null}
+ */
+const classifyGroupOpError = (err) => {
+    const msg = err instanceof Error ? err.message : String(err)
+    if (msg.includes('account_reachout_restricted') || msg.includes('reachout'))
+        return GROUP_OP_ERRORS.REACHOUT_RESTRICTED
+    if (msg.includes('rate-overlimit') || msg.includes('429')) return GROUP_OP_ERRORS.RATE_OVERLIMIT
+    if (msg.includes('locked')) return GROUP_OP_ERRORS.GROUP_LOCKED
+    if (msg.includes('gone')) return GROUP_OP_ERRORS.INVITE_EXPIRED
+    return null
+}
+exports.classifyGroupOpError = classifyGroupOpError
+
+/**
+ * Check whether a groupParticipantsUpdate result contains a privacy-block 403
+ * with an invite code that should be used instead of direct add.
+ * @param {Array} result - Result from sock.groupParticipantsUpdate()
+ * @returns {{ blocked: boolean, inviteCode?: string, inviteLink?: string }}
+ */
+const extractPrivacyBlock = (result) => {
+    if (!Array.isArray(result)) return { blocked: false }
+    for (const r of result) {
+        if (r.status !== '403') continue
+        const content = Array.isArray(r.content) ? r.content : []
+        for (const c of content) {
+            if (c.tag === 'add_request' && typeof c.attrs === 'object' && c.attrs.code) {
+                return {
+                    blocked: true,
+                    inviteCode: c.attrs.code,
+                    inviteLink: `https://chat.whatsapp.com/${c.attrs.code}`
+                }
+            }
+        }
+        return { blocked: true }
+    }
+    return { blocked: false }
+}
+exports.extractPrivacyBlock = extractPrivacyBlock
+
+class GroupOperationGuard {
+    /**
+     * @param {object} config
+     * @param {object} config.limits - Override per-operation limits
+     */
+    constructor(config = {}) {
+        this.limits = { ...DEFAULT_LIMITS, ...(config.limits || {}) }
+        this.windows = new Map()
+    }
+
+    /**
+     * Check whether an operation is allowed under the current rate limits.
+     * @param {'add'|'remove'|'create'|'invite'} op - Operation type
+     * @param {string} key - Unique key scoping the limit (e.g. groupJid)
+     * @returns {{ allowed: boolean, reason?: string, retryAfterSec?: number }}
+     */
+    check(op, key) {
+        const limit = this.limits[op]
+        if (!limit) return { allowed: true }
+        const windowKey = `${op}:${key}`
+        const now = Date.now()
+        const entry = this.windows.get(windowKey)
+
+        if (!entry || now > entry.resetAt) {
+            this.windows.set(windowKey, { count: 1, resetAt: now + limit.windowMs })
+            return { allowed: true }
+        }
+
+        if (entry.count >= limit.max) {
+            const retryAfterSec = Math.ceil((entry.resetAt - now) / 1000)
+            return {
+                allowed: false,
+                reason: `Too many ${op} attempts — wait ${Math.ceil(retryAfterSec / 60)} min before trying again.`,
+                retryAfterSec
+            }
+        }
+
+        entry.count++
+        return { allowed: true }
+    }
+
+    /**
+     * Reset the counter for a specific operation + key.
+     * @param {'add'|'remove'|'create'|'invite'} op
+     * @param {string} key
+     */
+    reset(op, key) {
+        this.windows.delete(`${op}:${key}`)
+    }
+
+    /**
+     * Snapshot of all active windows.
+     * @returns {object}
+     */
+    getStats() {
+        const stats = {}
+        for (const [key, val] of this.windows) {
+            stats[key] = { ...val }
+        }
+        return stats
+    }
+}
+
+exports.GroupOperationGuard = GroupOperationGuard
+module.exports = { GroupOperationGuard, classifyGroupOpError, extractPrivacyBlock, GROUP_OP_ERRORS }

package/lib/Utils/health-monitor.js

@@ -0,0 +1,207 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.health_monitor = void 0
+
+/**
+ * @file health-monitor.js
+ * @description Tracks disconnects, forbidden errors, logouts, and failed
+ *   messages to compute a ban-risk score with actionable recommendations.
+ * @author Denzy ZeroDay
+ */
+
+const default_config = {
+    disconnect_warning_threshold: 3,
+    disconnect_critical_threshold: 5,
+    failed_message_threshold: 5,
+    auto_pause_at: 'high'
+}
+
+class health_monitor {
+    constructor(config = {}) {
+        this.config = { ...default_config, ...config }
+        this.events = []
+        this.start_time = Date.now()
+        this.paused = false
+        this.last_risk = 'low'
+        this.last_bad_event_time = Date.now()
+        this.last_event_was_severe = false
+    }
+
+    /** Record a disconnection event */
+    record_disconnect(reason) {
+        const reason_str = String(reason)
+        if (reason_str === '403' || reason_str === 'forbidden') {
+            this.events.push({ type: 'forbidden', timestamp: Date.now(), detail: reason_str })
+            this.last_bad_event_time = Date.now()
+            this.last_event_was_severe = true
+        } else if (reason_str === '401' || reason_str === 'loggedOut') {
+            this.events.push({ type: 'loggedOut', timestamp: Date.now(), detail: reason_str })
+            this.last_bad_event_time = Date.now()
+            this.last_event_was_severe = true
+        } else if (reason_str === '463') {
+            this.events.push({
+                type: 'reachoutTimelocked',
+                timestamp: Date.now(),
+                detail: reason_str
+            })
+            this.last_bad_event_time = Date.now()
+            this.last_event_was_severe = false
+        } else {
+            this.events.push({ type: 'disconnect', timestamp: Date.now(), detail: reason_str })
+            this.last_bad_event_time = Date.now()
+            this.last_event_was_severe = false
+        }
+        this._check_and_notify()
+    }
+
+    /** Record a successful reconnection */
+    record_reconnect() {
+        this.events.push({ type: 'reconnect', timestamp: Date.now() })
+    }
+
+    /** Record a failed message send */
+    record_message_failed(error) {
+        this.events.push({ type: 'messageFailed', timestamp: Date.now(), detail: error })
+        this.last_bad_event_time = Date.now()
+        this.last_event_was_severe = false
+        this._check_and_notify()
+    }
+
+    /** Record a 463 reachout timelock error */
+    record_reachout_timelock(detail) {
+        this.events.push({ type: 'reachoutTimelocked', timestamp: Date.now(), detail })
+        this.last_bad_event_time = Date.now()
+        this.last_event_was_severe = false
+        this._check_and_notify()
+    }
+
+    /** Get current health status with ban-risk score and recommendation */
+    get_status() {
+        const now = Date.now()
+        this._cleanup(now)
+
+        const hour_events = this.events.filter((e) => now - e.timestamp < 3600000)
+        const disconnects = hour_events.filter((e) => e.type === 'disconnect').length
+        const forbidden = hour_events.filter((e) => e.type === 'forbidden').length
+        const logged_out = hour_events.filter((e) => e.type === 'loggedOut').length
+        const failed_messages = hour_events.filter((e) => e.type === 'messageFailed').length
+        const timelocked = hour_events.filter((e) => e.type === 'reachoutTimelocked').length
+
+        let score = 0
+        const reasons = []
+
+        if (forbidden > 0) {
+            score += 40 * forbidden
+            reasons.push(
+                `${forbidden} forbidden (403) error${forbidden > 1 ? 's' : ''} in last hour`
+            )
+        }
+        if (logged_out > 0) {
+            score += 60
+            reasons.push('Logged out by WhatsApp — possible temporary ban')
+        }
+        if (timelocked > 0) {
+            score += 25
+            reasons.push(
+                `${timelocked} reachout timelock (463) error${timelocked > 1 ? 's' : ''} in last hour`
+            )
+        }
+        if (disconnects >= this.config.disconnect_critical_threshold) {
+            score += 30
+            reasons.push(`${disconnects} disconnects in last hour (critical threshold)`)
+        } else if (disconnects >= this.config.disconnect_warning_threshold) {
+            score += 30
+            reasons.push(`${disconnects} disconnects in last hour`)
+        }
+        if (failed_messages >= this.config.failed_message_threshold) {
+            score += 20
+            reasons.push(`${failed_messages} failed messages in last hour`)
+        }
+
+        score = Math.min(100, score)
+        const minutes_since_last_bad = (now - this.last_bad_event_time) / 60000
+        const decay_rate = this.last_event_was_severe ? 2 : 5
+        score = Math.max(0, score - Math.floor(minutes_since_last_bad * decay_rate))
+
+        let risk
+        if (score >= 80) risk = 'critical'
+        else if (score >= 40) risk = 'high'
+        else if (score >= 15) risk = 'medium'
+        else risk = 'low'
+
+        let recommendation
+        switch (risk) {
+            case 'critical':
+                recommendation =
+                    'STOP ALL MESSAGING IMMEDIATELY. Disconnect and wait 24-48 hours before reconnecting.'
+                break
+            case 'high':
+                recommendation = 'Reduce messaging rate by 80%. Consider pausing for 1-2 hours.'
+                break
+            case 'medium':
+                recommendation = 'Reduce messaging rate by 50%. Increase delays between messages.'
+                break
+            default:
+                recommendation = 'Operating normally. Continue monitoring.'
+        }
+
+        const last_disconnect = [...this.events]
+            .reverse()
+            .find(
+                (e) => e.type === 'disconnect' || e.type === 'forbidden' || e.type === 'loggedOut'
+            )
+
+        return {
+            risk,
+            score,
+            reasons: reasons.length ? reasons : ['No issues detected'],
+            recommendation,
+            stats: {
+                disconnectsLastHour: disconnects,
+                failedMessagesLastHour: failed_messages,
+                forbiddenErrors: forbidden,
+                timelockErrors: timelocked,
+                uptimeMs: now - this.start_time,
+                lastDisconnectReason: last_disconnect?.detail
+            }
+        }
+    }
+
+    /** Check if sending should be paused based on current risk */
+    is_paused() {
+        if (this.paused) return true
+        const status = this.get_status()
+        const risk_order = ['low', 'medium', 'high', 'critical']
+        return risk_order.indexOf(status.risk) >= risk_order.indexOf(this.config.auto_pause_at)
+    }
+
+    /** Manually pause/resume sending */
+    set_paused(paused) {
+        this.paused = paused
+    }
+
+    /** Reset all tracked events */
+    reset() {
+        this.events = []
+        this.start_time = Date.now()
+        this.paused = false
+        this.last_risk = 'low'
+        this.last_bad_event_time = Date.now()
+        this.last_event_was_severe = false
+    }
+
+    _cleanup(now) {
+        this.events = this.events.filter((e) => now - e.timestamp < 21600000)
+    }
+
+    _check_and_notify() {
+        const status = this.get_status()
+        if (status.risk !== this.last_risk) {
+            this.last_risk = status.risk
+            this.config.onRiskChange?.(status)
+        }
+    }
+}
+
+exports.health_monitor = health_monitor
+module.exports = { health_monitor }

package/lib/Utils/history.js

@@ -0,0 +1,122 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getHistoryMsg =
+    exports.downloadAndProcessHistorySyncNotification =
+    exports.processHistoryMessage =
+    exports.downloadHistory =
+        void 0
+const util_1 = require('util')
+const zlib_1 = require('zlib')
+const WAProto_1 = require('../../WAProto')
+const Types_1 = require('../Types')
+const WABinary_1 = require('../WABinary')
+const generics_1 = require('./generics')
+const messages_1 = require('./messages')
+const messages_media_1 = require('./messages-media')
+const inflatePromise = (0, util_1.promisify)(zlib_1.inflate)
+const downloadHistory = async (msg, options) => {
+    const stream = await (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', {
+        options
+    })
+    const bufferArray = []
+    for await (const chunk of stream) {
+        bufferArray.push(chunk)
+    }
+    let buffer = Buffer.concat(bufferArray)
+    // decompress buffer
+    buffer = await inflatePromise(buffer)
+    const syncData = WAProto_1.proto.HistorySync.decode(buffer)
+    return syncData
+}
+exports.downloadHistory = downloadHistory
+const processHistoryMessage = (item) => {
+    var _a, _b, _c
+    const messages = []
+    const contacts = []
+    const chats = []
+    switch (item.syncType) {
+        case WAProto_1.proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case WAProto_1.proto.HistorySync.HistorySyncType.RECENT:
+        case WAProto_1.proto.HistorySync.HistorySyncType.FULL:
+        case WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                contacts.push({
+                    id: chat.id,
+                    name: chat.name || undefined,
+                    lid: chat.lidJid || undefined,
+                    jid: (0, WABinary_1.isJidUser)(chat.id) ? chat.id : undefined
+                })
+                const msgs = chat.messages || []
+                delete chat.messages
+                delete chat.archived
+                delete chat.muteEndTime
+                delete chat.pinned
+                for (const item of msgs) {
+                    const message = item.message
+                    messages.push(message)
+                    if (!((_a = chat.messages) === null || _a === void 0 ? void 0 : _a.length)) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }]
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = (0, generics_1.toNumber)(
+                            message.messageTimestamp
+                        )
+                    }
+                    if (
+                        (message.messageStubType ===
+                            Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                            message.messageStubType ===
+                                Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        ((_b = message.messageStubParameters) === null || _b === void 0
+                            ? void 0
+                            : _b[0])
+                    ) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName:
+                                (_c = message.messageStubParameters) === null || _c === void 0
+                                    ? void 0
+                                    : _c[0]
+                        })
+                    }
+                }
+                if ((0, WABinary_1.isJidUser)(chat.id) && chat.readOnly && chat.archived) {
+                    delete chat.readOnly
+                }
+                chats.push({ ...chat })
+            }
+            break
+        case WAProto_1.proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname })
+            }
+            break
+    }
+    return {
+        chats,
+        contacts,
+        messages
+    }
+}
+exports.processHistoryMessage = processHistoryMessage
+const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+    const historyMsg = await (0, exports.downloadHistory)(msg, options)
+    return (0, exports.processHistoryMessage)(historyMsg)
+}
+exports.downloadAndProcessHistorySyncNotification = downloadAndProcessHistorySyncNotification
+const getHistoryMsg = (message) => {
+    var _a
+    const normalizedContent = !!message
+        ? (0, messages_1.normalizeMessageContent)(message)
+        : undefined
+    const anyHistoryMsg =
+        (_a =
+            normalizedContent === null || normalizedContent === void 0
+                ? void 0
+                : normalizedContent.protocolMessage) === null || _a === void 0
+            ? void 0
+            : _a.historySyncNotification
+    return anyHistoryMsg
+}
+exports.getHistoryMsg = getHistoryMsg

package/lib/Utils/human-entropy.js

@@ -0,0 +1,226 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.HumanEntropyService = exports.createHumanEntropyService = void 0
+
+/**
+ * @file human-entropy.js
+ * @description Background noise for WA sessions — fake human activity
+ *   to prevent bot detection. Performs random typing presence, delayed
+ *   read receipts, and availability status toggles periodically.
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), original by baileys-antiban contributors
+ */
+
+const DEFAULT_CONFIG = {
+    enabled: true,
+    minIntervalMs: 2 * 60 * 60 * 1000, // 2 hours
+    maxIntervalMs: 6 * 60 * 60 * 1000, // 6 hours
+    maxRecentContacts: 30,
+    typingProbability: 0.3,
+    typingMinMs: 3000,
+    typingMaxMs: 8000,
+    readReceiptProbability: 0.2,
+    readReceiptMinDelayMs: 10 * 60 * 1000, // 10 min
+    readReceiptMaxDelayMs: 60 * 60 * 1000, // 60 min
+    presenceToggleProbability: 0.15,
+    presenceToggleMinMs: 30 * 1000, // 30 sec
+    presenceToggleMaxMs: 2 * 60 * 1000 // 2 min
+}
+
+class HumanEntropyService {
+    /**
+     * @param {object} sock - Baileys WASocket instance
+     * @param {object} config - Optional config overrides
+     */
+    constructor(sock, config = {}) {
+        this.sock = sock
+        this.config = { ...DEFAULT_CONFIG, ...config }
+        this.recentContacts = []
+        this.unreadMessages = []
+        this.cycleTimer = null
+        this.isRunning = false
+        this.stats = {
+            cyclesExecuted: 0,
+            typingActionsPerformed: 0,
+            readReceiptsMarked: 0,
+            presenceToggles: 0,
+            errors: 0,
+            lastCycleAt: null,
+            nextCycleAt: null
+        }
+    }
+
+    /**
+     * Start the entropy service.
+     * Call this after sock is connected.
+     */
+    start() {
+        if (!this.config.enabled) return
+        if (this.isRunning) return
+        this.isRunning = true
+        this._scheduleNextCycle()
+    }
+
+    /**
+     * Stop the entropy service.
+     */
+    stop() {
+        this.isRunning = false
+        if (this.cycleTimer) {
+            clearTimeout(this.cycleTimer)
+            this.cycleTimer = null
+        }
+        this.stats.nextCycleAt = null
+    }
+
+    /**
+     * Track an incoming message to build recent contacts list.
+     * Call this from messages.upsert event handler.
+     * @param {object} msg - Raw Baileys message
+     */
+    trackMessage(msg) {
+        try {
+            if (msg.key?.fromMe) return
+            const jid = msg.key?.remoteJid
+            if (!jid) return
+
+            const isGroup = jid.endsWith('@g.us')
+            const existingIdx = this.recentContacts.findIndex((c) => c.jid === jid)
+
+            if (existingIdx >= 0) {
+                this.recentContacts[existingIdx].lastMessageAt = new Date()
+            } else {
+                this.recentContacts.push({ jid, lastMessageAt: new Date(), isGroup })
+            }
+
+            if (this.recentContacts.length > this.config.maxRecentContacts) {
+                this.recentContacts.sort((a, b) => b.lastMessageAt - a.lastMessageAt)
+                this.recentContacts = this.recentContacts.slice(0, this.config.maxRecentContacts)
+            }
+
+            if (msg.key?.id && msg.message) {
+                this.unreadMessages.push({ jid, messageKey: msg.key, receivedAt: new Date() })
+                if (this.unreadMessages.length > 50) {
+                    this.unreadMessages = this.unreadMessages.slice(-50)
+                }
+            }
+        } catch (err) {
+            this.stats.errors++
+        }
+    }
+
+    /**
+     * Get current stats
+     */
+    getStats() {
+        return { ...this.stats }
+    }
+
+    _scheduleNextCycle() {
+        if (!this.isRunning) return
+        const delay = this._rand(this.config.minIntervalMs, this.config.maxIntervalMs)
+        this.stats.nextCycleAt = new Date(Date.now() + delay)
+        this.cycleTimer = setTimeout(() => {
+            this._executeCycle()
+                .catch(() => this.stats.errors++)
+                .finally(() => this._scheduleNextCycle())
+        }, delay)
+    }
+
+    async _executeCycle() {
+        if (!this.isRunning || this.recentContacts.length === 0) return
+
+        this.stats.cyclesExecuted++
+        this.stats.lastCycleAt = new Date()
+
+        const actions = []
+
+        if (Math.random() < this.config.typingProbability) {
+            actions.push(this._performTyping())
+        }
+        if (Math.random() < this.config.readReceiptProbability && this.unreadMessages.length > 0) {
+            actions.push(this._performReadReceipt())
+        }
+        if (Math.random() < this.config.presenceToggleProbability) {
+            actions.push(this._performPresenceToggle())
+        }
+
+        await Promise.allSettled(actions)
+    }
+
+    async _performTyping() {
+        try {
+            const eligible = this.recentContacts.filter((c) => !c.isGroup)
+            if (eligible.length === 0) return
+            const contact = eligible[Math.floor(Math.random() * eligible.length)]
+            const duration = this._rand(this.config.typingMinMs, this.config.typingMaxMs)
+
+            await this.sock.sendPresenceUpdate('composing', contact.jid)
+            await this._sleep(duration)
+            await this.sock.sendPresenceUpdate('paused', contact.jid)
+
+            this.stats.typingActionsPerformed++
+        } catch (err) {
+            this.stats.errors++
+        }
+    }
+
+    async _performReadReceipt() {
+        try {
+            const msg = this.unreadMessages[Math.floor(Math.random() * this.unreadMessages.length)]
+            if (!msg) return
+            const delay = this._rand(
+                this.config.readReceiptMinDelayMs,
+                this.config.readReceiptMaxDelayMs
+            )
+            await this._sleep(delay)
+            await this.sock.readMessages([msg.messageKey])
+            this.unreadMessages = this.unreadMessages.filter((m) => m !== msg)
+            this.stats.readReceiptsMarked++
+        } catch (err) {
+            this.stats.errors++
+        }
+    }
+
+    async _performPresenceToggle() {
+        try {
+            const duration = this._rand(
+                this.config.presenceToggleMinMs,
+                this.config.presenceToggleMaxMs
+            )
+            await this.sock.sendPresenceUpdate('available')
+            await this._sleep(duration)
+            await this.sock.sendPresenceUpdate('unavailable')
+            this.stats.presenceToggles++
+        } catch (err) {
+            this.stats.errors++
+        }
+    }
+
+    _rand(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min
+    }
+
+    _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms))
+    }
+}
+
+/**
+ * Factory function
+ * @param {object} sock - Baileys WASocket
+ * @param {object} config - Optional config
+ */
+const createHumanEntropyService = (sock, config = {}) => {
+    const service = new HumanEntropyService(sock, config)
+    return {
+        start: () => service.start(),
+        stop: () => service.stop(),
+        trackMessage: (msg) => service.trackMessage(msg),
+        getStats: () => service.getStats()
+    }
+}
+
+exports.HumanEntropyService = HumanEntropyService
+exports.createHumanEntropyService = createHumanEntropyService
+module.exports = { HumanEntropyService, createHumanEntropyService }