@shoru/kitten 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+<div align="left">
+
+<img src="https://files.catbox.moe/j7dpni.png" align="right" width="200" alt="Kitten Logo">
+
+<a name="-kitten"></a>
+# **Kitten Framework**
+
+### A powerful `Node.js` framework to simplify making WhatsApp Bots. built on top of the [Baileys](https://github.com/WhiskeySockets/Baileys) library. 😺
+
+![State](https://img.shields.io/badge/State-BETA-5a67d8?style=for-the-badge&logo=activity)
+[![npm](https://img.shields.io/npm/v/@shoru/kitten.svg?style=for-the-badge)](https://www.npmjs.com/package/@shoru/kitten)
+[![License](https://img.shields.io/github/license/Mangaka-bot/kitten-wa?style=for-the-badge)](https://github.com/Mangaka-bot/kitten-wa/blob/main/LICENSE)
+
+</div>
+
+---
+
+<br clear="left"/>
+
+<div align="center">
+
+
+**Made with ❤️ for Whatsapp community**
+</div>

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@shoru/kitten",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "A powerful Node.js framework to simplify making WhatsApp Bots",
+  "main": "src/index.js",
+    "repository": {
+    "url": "git+https://github.com/Mangaka-bot/kitten-wa.git"
+  },
+  "scripts": {
+    "start": "node --no-warnings src/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "imports": {
+    "#utils.js": "./src/utils/index.js",
+    "#config.js": "./src/config/default.js",
+    "#auth.js": "./src/auth/index.js",
+    "#internals.js": "./src/internals/index.js",
+    "#client.js": "./src/client/index.js"
+  },
+  "exports": {
+    ".":  "./src/index.js"
+  },
+  "author": "Aymane Shoru",
+  "license": "MIT",
+  "dependencies": {
+    "@hapi/boom": "^10.0.1",
+    "@inquirer/prompts": "^8.1.0",
+    "@shoru/spindle": "^1.0.6",
+    "baileys": "^7.0.0-rc.9",
+    "chalk": "^5.6.2",
+    "cosmiconfig": "^9.0.0",
+    "defu": "^6.1.4",
+    "lmdb": "^3.4.4",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3",
+    "qrcode-terminal": "^0.12.0"
+  }
+}

package/src/auth/index.js

@@ -0,0 +1,2 @@
+export * from "./lmdb-auth-state.js";
+export * from "./init-session.js";

package/src/auth/init-session.js

@@ -0,0 +1,21 @@
+import { makeWASocket } from "baileys";
+import { useLMDBAuthState } from "./lmdb-auth-state.js";
+import { config } from "#internals.js";
+
+export const initSession = async ({ socketConfig, id } = {}) => {
+  try {
+    const { state, saveCreds, session } = await useLMDBAuthState(id);
+  
+    const sock = makeWASocket({ 
+      auth: state,
+      ...config.socket, 
+      ...socketConfig
+    });
+  
+    sock.ev.on("creds.update", saveCreds);
+
+    return { sock, session };
+  } catch (err) {
+    throw new Error(`[INIT_SESSION] Failed to initialize session: ${err.message}`, { cause: err });
+  }
+};

package/src/auth/lmdb-auth-state.js

@@ -0,0 +1,171 @@
+import { proto, initAuthCreds } from "baileys";
+import { LMDBManager, logger } from "#internals.js";
+import { serialize, deserialize } from "#utils.js";
+
+const KEY_PREFIX = "baileys";
+const COUNTER_KEY = `${KEY_PREFIX}:__meta__:counter`;
+const SESSION_PREFIX = `${KEY_PREFIX}:__sessions__:`;
+
+const keyBuilder = (sessionId) => {
+  const prefix = `${KEY_PREFIX}:${sessionId}:`;
+  return {
+    sessionId,
+    sessionPrefix: prefix,
+    creds: `${prefix}creds`,
+    forKey: (type, id) => `${prefix}${type}:${id}`,
+  };
+};
+
+const genID = async (db) => {
+  return db.transaction(() => {
+    const id = (db.get(COUNTER_KEY) ?? 0) + 1;
+    db.put(COUNTER_KEY, id);
+    return id;
+  });
+};
+
+const getSessionId = async (db, input) => {
+  if (input == null) return genID(db);
+  if (Number.isInteger(input) && input >= 0) return input;
+  throw new TypeError(
+    'Invalid sessionId: expected null/undefined or non-negative integer'
+  );
+};
+
+export async function useLMDBAuthState(inputSessionId) {
+  const { db } = LMDBManager;
+  const sessionId = await getSessionId(db, inputSessionId);
+  const keys = keyBuilder(sessionId);
+
+  const writeCreds = async (credsData) => {
+    await db.put(keys.creds, serialize(credsData));
+  };
+
+  const getKeys = (type, ids) => {
+    if (!ids.length) return {};
+
+    const keyList = ids.map((id) => keys.forKey(type, id));
+    const values = db.getMany(keyList);
+
+    const result = {};
+    for (let i = 0; i < ids.length; i++) {
+      const rawValue = values[i];
+
+      if (rawValue) {
+        try {
+          let parsed = deserialize(rawValue);
+          if (type === "app-state-sync-key" && parsed) {
+            parsed = proto.Message.AppStateSyncKeyData.fromObject(parsed);
+          }
+          result[ids[i]] = parsed;
+        } catch (err) {
+          logger.error(
+            err,
+            `[LMDBAuthState] Deserialize error: ${type}:${ids[i]}`
+          );
+          db.remove(keys.forKey(type, ids[i]));
+        }
+      }
+    }
+    return result;
+  };
+
+  const setKeys = async (data) => {
+    await db.batch(() => {
+      for (const [category, categoryData] of Object.entries(data)) {
+        if (!categoryData) continue;
+        for (const [id, value] of Object.entries(categoryData)) {
+          const key = keys.forKey(category, id);
+          if (value != null) {
+            db.put(key, serialize(value));
+          } else {
+            db.remove(key);
+          }
+        }
+      }
+    });
+  };
+
+  const clearKeys = async () => {
+    let count = 0;
+    await db.batch(() => {
+      for (const { key } of db.getRange({
+        start: keys.sessionPrefix,
+        end: `${keys.sessionPrefix}\xFF`,
+      })) {
+        if (key !== keys.creds) {
+          db.remove(key);
+          count++;
+        }
+      }
+    });
+    logger.debug(`[LMDBAuthState] Cleared ${count} keys`);
+  };
+
+  const deleteSession = async () => {
+    await db.batch(() => {
+      for (const { key } of db.getRange({
+        start: keys.sessionPrefix,
+        end: `${keys.sessionPrefix}\xFF`,
+      })) {
+        db.remove(key);
+      }
+      db.remove(`${SESSION_PREFIX}${sessionId}`);
+    });
+
+    logger.debug(`[LMDBAuthState] Deleted session ${sessionId}`);
+  };
+
+  const creds = await db.transaction(() => {
+    const existing = db.get(keys.creds);
+    if (existing != null) {
+      return deserialize(existing);
+    }
+
+    const newCreds = initAuthCreds();
+    db.put(keys.creds, serialize(newCreds));
+    db.put(`${SESSION_PREFIX}${sessionId}`, true);
+    return newCreds;
+  });
+
+  return {
+    state: {
+      creds,
+      keys: {
+        get: getKeys,
+        set: setKeys,
+        clear: clearKeys,
+      },
+    },
+    saveCreds: () => writeCreds(creds),
+    session: {
+      delete: deleteSession,
+      clear: clearKeys,
+      id: sessionId,
+    },
+  };
+}
+
+export function listSessions() {
+  if (!LMDBManager.isOpen) return [];
+
+  const { db } = LMDBManager;
+  const sessions = [];
+
+  for (const { key } of db.getRange({
+    start: SESSION_PREFIX,
+    end: `${SESSION_PREFIX}\xFF`,
+  })) {
+    const id = parseInt(key.slice(SESSION_PREFIX.length), 10);
+    if (!isNaN(id)) sessions.push(id);
+  }
+
+  return sessions.sort((a, b) => a - b);
+}
+
+export function sessionExists(sessionId) {
+  if (!Number.isInteger(sessionId) || sessionId < 0 || !LMDBManager.isOpen)
+    return false;
+  const { db } = LMDBManager;
+  return db.get(`${SESSION_PREFIX}${sessionId}`) != null;
+}

package/src/client/client.js

@@ -0,0 +1,418 @@
+import { DisconnectReason } from "baileys";
+import { Boom } from "@hapi/boom";
+import qrcode from "qrcode-terminal";
+import chalk from "chalk";
+import { logger } from "#internals.js";
+import { initSession } from "#auth.js";
+import { pauseSpinner } from "#utils.js";
+import { getConnectionConfig } from "./getConnectionConfig.js";
+
+export const ConnectionState = Object.freeze({
+  DISCONNECTED: 'disconnected',
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  RECONNECTING: 'reconnecting',
+});
+
+class ConnectionError extends Error {
+  constructor(message, { statusCode, recoverable = true } = {}) {
+    super(message);
+    this.name = "ConnectionError";
+    this.statusCode = statusCode;
+    this.recoverable = recoverable;
+  }
+}
+
+const DISCONNECT_HANDLERS = new Map([
+  [DisconnectReason.connectionClosed, { message: "Connection closed", recoverable: true }],
+  [DisconnectReason.restartRequired, { message: "QR Scanned", recoverable: true }],
+  [DisconnectReason.timedOut, { message: "Connection timed out", recoverable: true }],
+  [DisconnectReason.connectionLost, { message: "Connection lost", recoverable: true }],
+  [DisconnectReason.unavailableService, { message: "Service unavailable", recoverable: true }],
+  [DisconnectReason.loggedOut, { message: "Session logged out", recoverable: true, deleteSession: true }],
+  [DisconnectReason.forbidden, { message: "Account banned", recoverable: false, deleteSession: true }],
+  [405, { message: "Not logged in", recoverable: true, deleteSession: true }],
+]);
+
+export class Client {
+  sock = null;
+  session = null;
+  id = null;
+
+  #flag = "";
+  #qr = null;
+  #state = ConnectionState.DISCONNECTED;
+  #cancelWait
+  #isConfiguring = false;
+  #hasConnectedOnce = false;
+
+  #socketConfig = null;
+  #authConfig = null;
+
+  #reconnectAttempts = 0;
+  #reconnectTimer = null;
+  #isShuttingDown = false;
+
+  #pendingConnect = null;
+
+  #maxRetries;
+  #backoff;
+
+  #onPairing;
+  #onConnect;
+  #onReconnect;
+  #onDisconnect;
+  #onStateChange;
+
+  constructor(options = {}) {
+    const {
+      id,
+      maxRetries = 30,
+      backoff = (attempt) => Math.min(1000 * Math.pow(2, attempt - 1), 60_000),
+      onPairing = null,
+      onConnect = null,
+      onReconnect = null,
+      onDisconnect = null,
+      onStateChange = null,
+      socketConfig = {}
+    } = options;
+
+    this.id = id;
+    this.#socketConfig = socketConfig;
+    this.#maxRetries = maxRetries;
+    this.#backoff = backoff;
+    this.#onPairing = onPairing;
+    this.#onConnect = onConnect;
+    this.#onReconnect = onReconnect;
+    this.#onDisconnect = onDisconnect;
+    this.#onStateChange = onStateChange;
+  }
+
+  get state() {
+    return this.#state;
+  }
+
+  get isConnected() {
+    return this.#state === ConnectionState.CONNECTED;
+  }
+
+  get reconnectAttempts() {
+    return this.#reconnectAttempts;
+  }
+
+  // State Management
+
+  #setState(newState) {
+    const oldState = this.#state;
+    if (oldState === newState) return;
+
+    this.#state = newState;
+    this.#emit('stateChange', { oldState, newState });
+  }
+
+  #emit(event, data = {}) {
+    const callbacks = {
+      connect: this.#onConnect,
+      reconnect: this.#onReconnect,
+      disconnect: this.#onDisconnect,
+      stateChange: this.#onStateChange,
+    };
+
+    const callback = callbacks[event];
+    if (typeof callback !== 'function') return;
+
+    queueMicrotask(() => {
+      try {
+        callback({ ...data, client: this });
+      } catch (err) {
+        logger.error(err, `[${this.#flag}] Error in ${event} callback`);
+      }
+    });
+  }
+
+  // Connection Management
+
+  async connect() {
+    if (this.#isShuttingDown) {
+      throw new Error(`[${this.#flag}] Client is shutting down`);
+    }
+
+    if (this.#state === ConnectionState.CONNECTED) {
+      return { sock: this.sock, session: this.session, id: this.id };
+    }
+
+    if (this.#pendingConnect) {
+      return this.#pendingConnect.promise;
+    }
+
+    return this.#initConnection();
+  }
+
+  async #initConnection() {
+    this.#setState(ConnectionState.CONNECTING);
+    this.#reconnectAttempts = 0;
+
+    this.#pendingConnect = this.#createDeferred();
+
+    try {
+      await this.#createSocket();
+    } catch (err) {
+      this.#setState(ConnectionState.DISCONNECTED);
+      this.#resolvePending(null, err);
+    }
+
+    return this.#pendingConnect.promise;
+  }
+
+  #createDeferred() {
+    let resolve, reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+
+  #resolvePending(value, error = null) {
+    if (!this.#pendingConnect) return;
+
+    const { resolve, reject } = this.#pendingConnect;
+    this.#pendingConnect = null;
+
+    if (error) {
+      reject(error);
+    } else {
+      resolve(value);
+    }
+  }
+
+  async #createSocket() {
+    this.#cleanupSocket();
+
+    const { sock, session } = await initSession({
+      socketConfig: this.#socketConfig,
+      id: this.id,
+    });
+
+    this.sock = sock;
+    this.session = session;
+    this.id = session.id;
+    this.#flag = `CLIENT-${session.id}`;
+
+    this.sock.ev.on("connection.update", (update) => {
+      this.#handleConnectionUpdate(update);
+    });
+  }
+
+  async #handleConnectionUpdate({ connection, lastDisconnect, qr }) {
+    if (this.#isShuttingDown) return;
+
+    try {
+      if (qr) {
+        await this.#handleAuth(qr);
+      } else if (connection === "open") {
+        this.#onConnectionOpen();
+      } else if (connection === "close") {
+        await this.#onConnectionClose(lastDisconnect);
+      }
+    } catch (err) {
+      logger.error(err, `[${this.#flag}] Error in connection update handler`);
+      this.#resolvePending(null, err);
+    }
+  }
+
+  #onConnectionOpen() {
+    const wasReconnecting = this.#state === ConnectionState.RECONNECTING;
+    this.#setState(ConnectionState.CONNECTED);
+
+    const attempts = this.#reconnectAttempts;
+    this.#reconnectAttempts = 0;
+
+    if (wasReconnecting) {
+      this.#emit('reconnect', { attempts });
+      logger.debug(`[${this.#flag}] Reconnected after ${attempts} attempt(s)`);
+    } else {
+      this.#hasConnectedOnce = true;
+      this.#emit('connect');
+      logger.debug(`[${this.#flag}] Connected successfully`);
+      this.#resolvePending({ sock: this.sock, session: this.session });
+    }
+  }
+
+  async #onConnectionClose(lastDisconnect) {
+    const disconnectInfo = this.#parseDisconnectReason(lastDisconnect);
+    const { message, statusCode, recoverable, deleteSession } = disconnectInfo;
+
+    if (message === "QR Scanned" && !this.#onPairing) {
+      console.clear();
+    }
+
+    const level = recoverable ? 'debug' : 'warn';
+
+    logger[level](`[${this.#flag}] Disconnected: ${message} (code: ${statusCode})`);
+
+    if (this.#hasConnectedOnce) {
+      this.#emit('disconnect', { message, statusCode, recoverable });
+    }
+
+    if (deleteSession) {
+      await this.session?.delete().catch((err) => {
+        logger.error(err, `[${this.#flag}] Failed to delete session`);
+      });
+    }
+
+    if (!recoverable || this.#isShuttingDown) {
+      this.#setState(ConnectionState.DISCONNECTED);
+      this.#resolvePending(null, new ConnectionError(message, { statusCode, recoverable }));
+      return;
+    }
+
+    await this.#scheduleReconnect(message);
+  }
+
+  // Reconnection Logic
+
+  async #scheduleReconnect(reason) {
+    this.#reconnectAttempts++;
+
+    if (this.#reconnectAttempts > this.#maxRetries) {
+      const err = new ConnectionError(
+        `Max reconnection attempts (${this.#maxRetries}) exceeded`,
+        { recoverable: false }
+      );
+      this.#setState(ConnectionState.DISCONNECTED);
+      this.#resolvePending(null, err);
+      logger.error(err, `[${this.#flag}] ${err.message}`);
+      return;
+    }
+
+    if (this.#hasConnectedOnce) {
+      this.#setState(ConnectionState.RECONNECTING);
+    }
+
+    const delay = this.#backoff(this.#reconnectAttempts);
+
+    const retriesInfo = this.#maxRetries !== Infinity ? `(${this.#reconnectAttempts}/${this.#maxRetries})` : '';
+
+    logger.debug(`[${this.#flag}] ${reason}. Reconnecting in ${delay} ms`);
+
+    const cancelled = await this.#wait(delay);
+    if (cancelled || this.#isShuttingDown) return;
+
+    logger.debug(`[${this.#flag}] Executing reconnect attempt ${retriesInfo}`);
+
+    try {
+      await this.#createSocket();
+    } catch (err) {
+      logger.error(err, `[${this.#flag}] Socket creation failed during reconnect`);
+    }
+  }
+
+  #wait(ms) {
+    return new Promise((resolve) => {
+      this.#reconnectTimer = setTimeout(() => {
+        this.#reconnectTimer = null;
+        resolve(false);
+      }, ms);
+
+      this.#cancelWait = () => resolve(true);
+    });
+  }
+
+  #parseDisconnectReason(lastDisconnect) {
+    const boom = new Boom(lastDisconnect?.error);
+    const statusCode = boom?.output?.statusCode;
+    const handler = DISCONNECT_HANDLERS.get(statusCode);
+
+    if (!handler) {
+      return {
+        message: `Unknown disconnect reason (code: ${statusCode ?? 'unknown'})`,
+        statusCode,
+        recoverable: true,
+        deleteSession: false,
+      };
+    }
+
+    return { ...handler, statusCode };
+  }
+
+  // Authentication
+
+  async #handleAuth(qr) {
+    this.#qr = qr;
+    if (this.#isConfiguring) return;
+
+    if (typeof this.#onPairing === 'function') {
+      const requestPairingCode = this.sock?.requestPairingCode?.bind(this.sock);
+      await this.#onPairing({ qr: this.#qr, requestPairingCode });
+      return;
+    }
+
+    this.#isConfiguring = true;
+    this.#authConfig ??= await pauseSpinner(getConnectionConfig);
+    this.#isConfiguring = false;
+
+    if (this.#authConfig.type === "pn") {
+      const code = await this.sock.requestPairingCode(this.#authConfig.pn);
+      logger.prompt(this.#formatPairingCode(code));
+    } else {
+      qrcode.generate(this.#qr, { small: true });
+      process.stdout.write("\n");
+    }
+  }
+
+  #formatPairingCode(code) {
+    const formatted = code.match(/.{1,4}/g)?.join(" ") ?? code;
+    return `\n${chalk.green("> Your OTP Code: ")}${chalk.bold(formatted)}`;
+  }
+
+  // Cleanup & Shutdown
+
+  #cleanupSocket() {
+    if (!this.sock) return;
+
+    try {
+      this.sock.ev.removeAllListeners();
+    } catch { /* noop */ };
+
+    this.sock = null;
+  }
+
+  #clearReconnectTimer() {
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+      this.#cancelWait?.();
+    }
+  }
+
+  async disconnect() {
+    if (this.#isShuttingDown) return;
+    this.#isShuttingDown = true;
+
+    this.#clearReconnectTimer();
+    this.#resolvePending(null, new Error('Client disconnected'));
+
+    this.#cleanupSocket();
+    this.#setState(ConnectionState.DISCONNECTED);
+
+    this.#isShuttingDown = false;
+    this.#hasConnectedOnce = false;
+  }
+
+  async logout() {
+    try {
+      await this.sock?.logout();
+      await this.disconnect();
+      await this.session?.delete();
+    } catch (err) {
+      logger.error(err, `[${this.#flag}] Logging out failed: ${err.message}`)
+    }
+  }
+}
+
+export const getClient = async (options) => {
+  const client = new Client(options);
+  await client.connect();
+  return client;
+};

package/src/client/getConnectionConfig.js

@@ -0,0 +1,48 @@
+import { select, input } from "@inquirer/prompts";
+import chalk from "chalk";
+import { logger } from "#internals.js";
+
+export const getConnectionConfig = async () => {
+  try {
+    process.stdout.write("\n");
+    const type = await select({
+      message: "How would you like to connect?",
+      choices: [
+        {
+          name: " ⛶   QR Code",
+          value: "qr",
+          description: "Generate a secure code to scan"
+        },
+        {
+          name: " 🔑  Phone Number",
+          value: "pn",
+          description: "Receive a One Time Password"
+        }
+      ]
+    });
+    
+    if (type === "pn") {
+        console.log(chalk.yellow("\n  🔑  Phone Number Selected\n"));
+        
+        const pn = await input({
+          message: "Enter your phone number:",
+          validate: (value) => {
+              const digitsOnly = /^\d+$/.test(value);
+              if (!digitsOnly) return "Digits only (+1 (234) 567-8901 → 12345678901)";
+              const correctLength = /^.{7,15}$/.test(value);
+              if (!correctLength) return "Phone number length should be from 7 to 15 digits";
+              return true;
+          },
+          transformer: (value) =>  chalk.cyan(value)
+      });
+      
+      return { type, pn }
+    } else {
+      logger.prompt(chalk.cyan("\n  ⛶  QR Code Selected\n"));
+      return { type };
+    }
+  } catch {
+      logger.prompt(chalk.red("\nOperation cancelled"));
+      process.exit(0);
+  }
+};

package/src/client/index.js

@@ -0,0 +1,2 @@
+export * from "./getConnectionConfig.js"
+export * from "./client.js"

package/src/config/default.js

@@ -0,0 +1,26 @@
+import { Browsers } from "baileys";
+import pino from "pino";
+
+const socket = {
+  browser: Browsers.ubuntu('Chrome'),
+  markOnlineOnConnect: false,
+  syncFullHistory: false,
+  generateHighQualityLinkPreview: true,
+  shouldIgnoreJid: () => false,
+  shouldSyncHistoryMessage: () => false,
+  logger: pino({ level: "silent" }),
+}
+
+const db = {
+  path: './db',
+  compression: true,
+  mapSize: 2 * 1024 * 1024 * 1024, // 2 GB
+  maxReaders: 126,
+  noSync: false,
+  noMetaSync: false,
+};
+
+export default {
+  db,
+  socket
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export * from "./auth/index.js";
+export * from "./client/index.js";
+export * from "./internals/index.js";
+export * from "./utils/index.js";

package/src/internals/config.js

@@ -0,0 +1,40 @@
+import { cosmiconfig } from 'cosmiconfig';
+import { defu } from 'defu';
+
+const loadDefaultConfig = async () => {
+  try {
+    const module = await import('../config/default.js');
+    const defaultConfig = module?.default ?? module;
+
+    if (typeof defaultConfig !== 'object' || defaultConfig === null || Array.isArray(defaultConfig)) {
+      throw new Error(`[INTERNAL_CONFIG] default config must export an object`);
+    }
+    
+    return defaultConfig;
+  } catch (err) {
+    throw new Error(`[INTERNAL_CONFIG] Error loading default config: ${err.message}`, { cause: err });
+  }
+};
+
+const loadUserConfig = async () => {
+  try {
+    const explorer = cosmiconfig('kittenwa');
+    const result = await explorer.search();
+    return result?.config ?? {};
+  } catch (err) {
+    throw new Error(`[USER_CONFIG] Error loading user config: ${err.message}`, { cause: err });
+  }
+};
+
+export const loadConfig = async () => {
+  const [userConfig, defaultConfig] = await Promise.all([
+    loadUserConfig(),
+    loadDefaultConfig()
+  ]);
+  
+  return defu(userConfig, defaultConfig);
+};
+
+const configObject = await loadConfig()
+
+export const config = Object.freeze(configObject);

package/src/internals/index.js

@@ -0,0 +1,4 @@
+export * from "./logger.js";
+export * from "./lmdb-manager.js";
+export * from "./config.js"
+export * from "./spinner.js"

package/src/internals/lmdb-manager.js

@@ -0,0 +1,52 @@
+import { open } from 'lmdb';
+import { logger } from './logger.js';
+import { config } from './config.js';
+
+class LMDBDatabaseManager {
+  #db = null;
+  #config = config.db;
+  #isClosing = false;
+
+  constructor(config) {
+    this.#config = { ...this.#config, ...config };
+  }
+
+  get db() {
+    if (this.#isClosing) {
+      throw new Error('[LMDBManager] Database is closing');
+    }
+
+    if (!this.#db) {
+      this.#db = open(this.#config);
+    }
+
+    return this.#db;
+  }
+
+  get isOpen() {
+    return this.#db !== null && !this.#isClosing;
+  }
+
+  get config() {
+    return Object.freeze({ ...this.#config });
+  }
+
+  async close() {
+    if (!this.#db || this.#isClosing) return;
+
+    this.#isClosing = true;
+
+    try {
+      await this.#db.flushed;
+      await this.#db.close();
+    } catch (err) {
+      logger.error(err, '[LMDBManager] Error closing database');
+      throw err;
+    } finally {
+      this.#db = null;
+      this.#isClosing = false;
+    }
+  }
+}
+
+export const LMDBManager = new LMDBDatabaseManager();

package/src/internals/logger.js

@@ -0,0 +1,15 @@
+import pino from "pino";
+
+const logger = pino({
+  transport: {
+    target: "pino-pretty",
+    options: { 
+      colorize: true,
+      ignore: "pid,hostname",
+    }
+  }
+});
+
+logger.prompt = console.log.bind(console);
+
+export { logger };

package/src/internals/spinner.js

@@ -0,0 +1,3 @@
+import { spindle } from "@shoru/spindle";
+
+export const spinner = spindle();

package/src/utils/buffer-json.js

@@ -0,0 +1,11 @@
+import { BufferJSON } from 'baileys';
+
+export const serialize = (data) => {
+  if (data == null) return null;
+  return JSON.stringify(data, BufferJSON.replacer);
+} 
+
+export const deserialize = (json) => {
+  if (json == null) return null;
+  return JSON.parse(json, BufferJSON.reviver);
+};

package/src/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./buffer-json.js";
+export * from "./retry.js";
+export * from "./pause-spinner.js"

package/src/utils/pause-spinner.js

@@ -0,0 +1,12 @@
+import { spinner } from "#internals.js";
+
+export const pauseSpinner = async (action) => {
+  if (!spinner.isSpinning) return action();
+
+  spinner.stop();
+  try {
+    return await action();
+  } finally {
+    spinner.start();
+  }
+};

package/src/utils/retry.js

@@ -0,0 +1,29 @@
+export async function retry(fn, options = {}) {
+  const {
+    maxAttempts = 20,
+    backoff = (attempt) => Math.min(500 * attempt, 30_000),
+    shouldRetry = () => true,
+    onRetry = () => {},
+  } = options;
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastError = err;
+
+      if (attempt === maxAttempts || !shouldRetry(err, attempt)) {
+        throw err;
+      }
+
+      onRetry(err, attempt);
+      await wait(backoff(attempt));
+    }
+  }
+
+  throw lastError;
+}
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));