@shoru/kitten 0.1.1 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 <div align="left">
 
-<img src="https://files.catbox.moe/j7dpni.png" align="right" width="220" alt="Kitten Logo">
+<img src="https://files.catbox.moe/j7dpni.png" alt="Kitten Logo" style="width: 30%; max-width: 220px; height: auto; float: right; margin-left: 15px;">
 
 <a name="-kitten"></a>
 # **Kitten Framework**
@@ -73,6 +73,7 @@ import { getClient } from '@shoru/kitten';
 const { sock, session, id } = await getClient({
   id: 0,                    // Session ID (auto-generated if omitted)
   maxRetries: 30,           // Reconnection attempts
+  maxPairingAttempts: 20,   // Max pairing attempts before timeout (default: 20)
   silent: false,            // Suppress output
   socketConfig: {},         // Baileys socket overrides
   
@@ -88,6 +89,9 @@ const { sock, session, id } = await getClient({
   },
   onStateChange: ({ oldState, newState }) => {
     console.log(`State: ${oldState} → ${newState}`);
+  },
+  onPairingAttemptsExceeded: ({ client, maxAttempts }) => {
+    console.log(`Pairing attempts exceeded limit of ${maxAttempts}`);
   }
 });
 ```
@@ -95,17 +99,27 @@ const { sock, session, id } = await getClient({
 ### Custom Authentication
 
 ```javascript
-import qrcode from 'qrcode-terminal';
-
 const { sock, id } = await getClient({
-  onPairing: async ({ qr, requestPairingCode }) => {
+  maxPairingAttempts: 5,
+  onPairing: async ({ qr, requestPairingCode, attempts, maxAttempts }) => {
+    console.log(`Pairing attempt ${attempts}/${maxAttempts}`);
+
     // Option 1: Display QR code
     console.log('Scan QR:');
-    qrcode.generate(qr, { small: true });
+    await qr.print();
     
+    /* 
+    you can use:
+    const qrImg = await qr.buffer()
+    to send|save the QR code as a png image
+    */
+
     // Option 2: Use pairing code
     const code = await requestPairingCode('1234567890');
     console.log('Enter this code in WhatsApp:', code);
+  },
+  onPairingAttemptsExceeded: async ({ client, maxAttempts }) => {
+    console.log(`Pairing expired after ${maxAttempts} attempts!`);
   }
 });
 ```

package/internal-test/plugins/exp.js

@@ -1,6 +1,6 @@
 export const plugin = async (sock, ctx) => {
   console.log(JSON.stringify({...ctx, raw: undefined}, null, 1));
-  sock.sendMessage(ctx.roomId, { text: ctx.body }, { quoted: ctx.raw });
+  await sock.sendMessage(ctx.roomId, { text: "tst" }, { quoted: ctx.raw });
 }
 
 plugin.events = ['messages.upsert'];

package/internal-test/plugins/pairing.js

@@ -0,0 +1,96 @@
+import { getClient } from '../../src/index.js';
+
+export const plugin = async (sock, ctx) => {
+  const args = ctx.body?.trim().split(/\s+/) ?? [];
+  const type = args[1]?.toLowerCase();
+
+  if (!type || (type !== 'qr' && type !== 'otp')) {
+    return await sock.sendMessage(
+      ctx.roomId,
+      { text: 'Please specify the pairing type: `qr` or `otp`.\n\n*Usage:*\n- `!pairing qr`\n- `!pairing otp`' },
+      { quoted: ctx.raw }
+    );
+  }
+
+  const options = {
+    silent: true,
+    maxRetries: 2,
+    maxPairingAttempts: 1,
+    onPairingAttemptsExceeded: async () => {
+      await sock.sendMessage(
+        ctx.roomId,
+        { text: 'Pairing code expired. Please try again' },
+        { quoted: ctx.raw }
+      )
+    }
+  }
+
+  if (type === 'qr') {
+    await getClient({
+      ...options,
+      onPairing: async ({ qr }) => {
+        const qrImg = await qr.buffer();
+        await sock.sendMessage(
+          ctx.roomId,
+          { image: qrImg, caption: 'Scan this QR code to pair your device' },
+          { quoted: ctx.raw }
+        );
+      },
+      onPairingAttemptsExceeded: async () => {
+        await sock.sendMessage(
+          ctx.roomId,
+          { text: 'Pairing attempts exceeded. Please try again' },
+          { quoted: ctx.raw }
+        );
+      },
+      onConnect: async ({ client }) => {
+        await sock.sendMessage(
+          ctx.roomId,
+          { text: `Session *${client.id}* paired and connected successfully!` },
+          { quoted: ctx.raw }
+        );
+      },
+    });
+  } else if (type === 'otp') {
+    const phone = await ctx.pn();
+
+    if (!phone) {
+      return await sock.sendMessage(
+        ctx.roomId,
+        { text: 'Failed to extract phone number' },
+        { quoted: ctx.raw }
+      );
+      return;
+    }
+
+    await getClient({
+      ...options,
+      onPairing: async ({ requestPairingCode }) => {
+        const code = await requestPairingCode(phone);
+        const formattedCode = code?.match(/.{1,4}/g)?.join('-') ?? code;
+        await sock.sendMessage(
+          ctx.roomId,
+          { text: `Your OTP pairing code: *${formattedCode}*` },
+          { quoted: ctx.raw }
+        );
+      },
+      onPairingAttemptsExceeded: async () => {
+        await sock.sendMessage(
+          ctx.roomId,
+          { text: 'Pairing attempts exceeded. Please try again' },
+          { quoted: ctx.raw }
+        );
+      },
+      onConnect: async ({ client }) => {
+        await sock.sendMessage(
+          ctx.roomId,
+          { text: `Session *${client.id}* paired and connected successfully!` },
+          { quoted: ctx.raw }
+        );
+      },
+    });
+  }
+};
+
+plugin.events = ['messages.upsert'];
+plugin.match = ['pairing'];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shoru/kitten",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A powerful Node.js framework to simplify making WhatsApp Bots",
   "main": "src/index.js",
   "repository": {
@@ -29,7 +29,7 @@
     "@inquirer/prompts": "^8.7.0",
     "@shoru/spindle": "^1.0.7",
     "async-mutex": "^0.5.0",
-    "baileys": "github:WhiskeySockets/Baileys",
+    "baileys": "7.0.0-rc14",
     "chalk": "^6.0.0",
     "chokidar": "^5.0.0",
     "cosmiconfig": "^10.0.0",
@@ -37,6 +37,6 @@
     "lmdb": "^3.5.6",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "qrcode-terminal": "^0.12.0"
+    "qrcode": "^1.5.4"
   }
 }

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

@@ -31,10 +31,6 @@ const genID = async (db) => {
 
 const getSessionId = async (db, input) => {
   if (input == null) {
-    const existing = listSessions();
-    if (existing.length > 0) {
-      return existing[0];
-    }
     return genID(db);
   }
   if (Number.isInteger(input) && input >= 0) return input;

package/src/client/auth-handler.js

@@ -1,37 +1,14 @@
-import qrcode from 'qrcode-terminal';
 import chalk from 'chalk';
 import { ConnectionError } from './errors.js';
 import { ClientRegistry } from './registry.js';
 import { getConnectionConfig } from './getConnectionConfig.js';
+import { QR } from './qr.js';
 
-/**
- * Formats a pairing code into readable 4-character groups with styling.
- *
- * @param {string} code - The raw pairing code string
- * @returns {string} The styled formatted pairing code
- */
 export function formatPairingCode(code) {
   const formatted = code.match(/.{1,4}/g)?.join(' ') ?? code;
   return `\n${chalk.green('> Your OTP Code: ')}${chalk.bold(formatted)}`;
 }
 
-/**
- * Handles authentication for a client instance when a QR code or pairing challenge is received.
- *
- * @param {object} params
- * @param {string} params.qr - The QR code string
- * @param {any} params.rawSock - The raw WASocket instance
- * @param {string} params.flag - Identifier string for logging
- * @param {boolean} params.isSync - Whether the client is a background sync instance
- * @param {boolean} params.isSilent - Whether logging/prompts are suppressed
- * @param {Function|null} params.onPairing - Optional custom pairing callback
- * @param {object} params.logger - Logger instance
- * @param {object|null} params.authConfig - Cached auth config
- * @param {(config: object|null) => void} params.setAuthConfig - Setter for auth config
- * @param {boolean} params.pairingCodeRequested - Whether pairing code has already been requested
- * @param {(requested: boolean) => void} params.setPairingCodeRequested - Setter for pairingCodeRequested
- * @param {(err: Error) => void} params.onSyncAuthAbort - Callback when sync connection requires auth
- */
 export async function handleClientAuth({
   qr,
   rawSock,
@@ -39,6 +16,8 @@ export async function handleClientAuth({
   isSync,
   isSilent,
   onPairing,
+  attempts,
+  maxAttempts,
   logger,
   authConfig,
   setAuthConfig,
@@ -55,11 +34,13 @@ export async function handleClientAuth({
     return;
   }
 
+  const qrObj = qr instanceof QR ? qr : new QR(qr);
+
   if (ClientRegistry.isConfiguring) return;
 
   if (typeof onPairing === 'function') {
     const requestPairingCode = rawSock?.requestPairingCode?.bind(rawSock);
-    await onPairing({ qr, requestPairingCode });
+    await onPairing({ qr: qrObj, requestPairingCode, attempts, maxAttempts });
     return;
   }
 
@@ -90,8 +71,7 @@ export async function handleClientAuth({
       }
     }
   } else {
-    qrcode.generate(qr, { small: true });
+    await qrObj.print();
     process.stdout.write('\n');
   }
-}
-
+}

package/src/client/client.js

@@ -4,6 +4,7 @@ import { initSession, listSessions } from '#auth.js';
 import {
   ConnectionState,
   DEFAULT_MAX_RETRIES,
+  DEFAULT_MAX_PAIRING_ATTEMPTS,
   defaultBackoff,
   silentLogger,
   silentPino,
@@ -73,12 +74,14 @@ export class Client {
   #pairingCodeRequested = false;
 
   #reconnectAttempts = 0;
+  #pairingAttempts = 0;
   #reconnectTimer = null;
   #isShuttingDown = false;
 
   #pendingConnect = null;
 
   #maxRetries;
+  #maxPairingAttempts;
   #backoff;
 
   // Options
@@ -88,6 +91,7 @@ export class Client {
 
   // Callbacks
   #onPairing;
+  #onPairingAttemptsExceeded;
   #onConnect;
   #onReconnect;
   #onDisconnect;
@@ -97,10 +101,12 @@ export class Client {
     const {
       id,
       maxRetries = DEFAULT_MAX_RETRIES,
+      maxPairingAttempts = DEFAULT_MAX_PAIRING_ATTEMPTS,
       backoff = defaultBackoff,
       silent = false,
       sync = false,
       onPairing = null,
+      onPairingAttemptsExceeded = null,
       onConnect = null,
       onReconnect = null,
       onDisconnect = null,
@@ -111,11 +117,13 @@ export class Client {
     this.id = id;
     this.#socketConfig = socketConfig;
     this.#maxRetries = maxRetries;
+    this.#maxPairingAttempts = maxPairingAttempts;
     this.#backoff = backoff;
     this.#silent = silent;
     this.#sync = sync;
     this.#logger = silent ? silentLogger : logger;
     this.#onPairing = onPairing;
+    this.#onPairingAttemptsExceeded = onPairingAttemptsExceeded;
     this.#onConnect = onConnect;
     this.#onReconnect = onReconnect;
     this.#onDisconnect = onDisconnect;
@@ -145,6 +153,14 @@ export class Client {
     return this.#reconnectAttempts;
   }
 
+  get pairingAttempts() {
+    return this.#pairingAttempts;
+  }
+
+  get maxPairingAttempts() {
+    return this.#maxPairingAttempts;
+  }
+
   get ev() {
     return this.#ev;
   }
@@ -188,11 +204,15 @@ export class Client {
     const callback = callbacks[event];
     if (typeof callback !== 'function') return;
 
-    queueMicrotask(() => {
+    queueMicrotask(async () => {
       try {
-        callback({ ...data, client: this });
+        await callback({ ...data, client: this });
       } catch (err) {
-        this.#logger.error(err, `[${this.#flag}] Error in ${event} callback`);
+        try {
+          this.#logger.error(err, `[${this.#flag}] Error in ${event} callback`);
+        } catch {
+          // Prevent logger errors from becoming unhandled rejections
+        }
       }
     });
   }
@@ -218,6 +238,7 @@ export class Client {
   async #initConnection() {
     this.#setState(ConnectionState.CONNECTING);
     this.#reconnectAttempts = 0;
+    this.#pairingAttempts = 0;
     this.#pendingConnect = this.#createDeferred();
 
     try {
@@ -296,9 +317,36 @@ export class Client {
 
   async #handleConnectionUpdate({ connection, lastDisconnect, qr }) {
     if (this.#isShuttingDown) return;
-
+    
     try {
       if (qr) {
+        this.#pairingAttempts++;
+
+        if (this.#pairingAttempts > this.#maxPairingAttempts) {
+          this.#logger.warn(`[${this.#flag}] Max pairing attempts (${this.#maxPairingAttempts}) exceeded`);
+
+          if (typeof this.#onPairingAttemptsExceeded === 'function') {
+            try {
+              await this.#onPairingAttemptsExceeded({
+                client: this,
+                maxAttempts: this.#maxPairingAttempts,
+              });
+            } catch (cbErr) {
+              this.#logger.error(
+                cbErr,
+                `[${this.#flag}] Error in onPairingAttemptsExceeded callback`
+              );
+            }
+          }
+
+          this.#cleanupSocket();
+          this.#clearReconnectTimer();
+          this.#unregister();
+          this.#pairingAttempts = 0;
+          this.#setState(ConnectionState.DISCONNECTED);
+          return;
+        }
+
         this.#qr = qr;
         await handleClientAuth({
           qr: this.#qr,
@@ -307,6 +355,8 @@ export class Client {
           isSync: this.#sync,
           isSilent: this.#silent,
           onPairing: this.#onPairing,
+          attempts: this.#pairingAttempts,
+          maxAttempts: this.#maxPairingAttempts,
           logger: this.#logger,
           authConfig: this.#authConfig,
           setAuthConfig: (cfg) => {
@@ -341,6 +391,7 @@ export class Client {
 
     this.#register();
     this.#pairingCodeRequested = false;
+    this.#pairingAttempts = 0;
 
     if (!this.#plugins || this.#plugins.destroyed) {
       try {
@@ -398,6 +449,7 @@ export class Client {
       });
       this.#authConfig = null;
       this.#pairingCodeRequested = false;
+      this.#pairingAttempts = 0;
       this.#isNewSession = true;
       this.#hasEverConnected = false;
       this.#isFirstConnection = false;
@@ -437,14 +489,9 @@ export class Client {
   async #scheduleReconnect(reason) {
     this.#reconnectAttempts++;
 
-    if (this.#reconnectAttempts > this.#maxRetries) {
-      const err = new ConnectionError(
-        `Max reconnection attempts (${this.#maxRetries}) exceeded`,
-        { recoverable: false }
-      );
+    if (this.#reconnectAttempts > this.#maxRetries) {      
       this.#setState(ConnectionState.DISCONNECTED);
-      this.#resolvePending(null, err);
-      this.#logger.error(err, `[${this.#flag}] ${err.message}`);
+      this.#logger.warn(`[${this.#flag}] Max reconnection attempts (${this.#maxRetries}) exceeded`);
       return;
     }
 
@@ -530,6 +577,7 @@ export class Client {
     this.#isShuttingDown = false;
     this.#hasConnectedOnce = false;
     this.#pairingCodeRequested = false;
+    this.#pairingAttempts = 0;
   }
 
   async logout() {
@@ -540,6 +588,7 @@ export class Client {
       this.#isNewSession = null;
       this.#hasEverConnected = false;
       this.#isFirstConnection = false;
+      this.#pairingAttempts = 0;
     } catch (err) {
       this.#logger.error(err, `[${this.#flag}] Logging out failed`);
     }

package/src/client/constants.js

@@ -36,6 +36,7 @@ export const silentLogger = Object.freeze({
 export const silentPino = pino({ level: 'silent' });
 
 export const DEFAULT_MAX_RETRIES = 30;
+export const DEFAULT_MAX_PAIRING_ATTEMPTS = 20;
 
 export const defaultBackoff = (attempt) => Math.min(1000 * 2 ** (attempt - 1), 60_000);
 

package/src/client/qr.js

@@ -0,0 +1,35 @@
+import QRCode from 'qrcode';
+
+export class QR {
+  #raw;
+  constructor(raw) {
+    this.#raw = typeof raw === 'string' ? raw : (raw?.raw ?? String(raw ?? ''));
+  }
+
+  get raw() {
+    return this.#raw;
+  }
+
+  async print(options = {}) {
+    const terminalQR = await QRCode.toString(this.#raw, {
+      type: 'terminal',
+      small: true,
+      ...options,
+    });
+    console.log(terminalQR);
+    return terminalQR;
+  }
+
+  async buffer(options = {}) {
+    return QRCode.toBuffer(this.#raw, {
+      type: 'png',
+      margin: 2,
+      scale: 4,
+      ...options,
+    });
+  }
+
+  toString() {
+    return this.#raw;
+  }
+}

package/src/internals/index.js

@@ -1,4 +1,6 @@
-export * from './config.js';
-export * from './logger.js';
-export * from './spinner.js';
+import './libsignal-patch.js';
+
+export * from './config.js';
+export * from './logger.js';
+export * from './spinner.js';
 export * from './lmdb-manager.js';

package/src/internals/libsignal-patch.js

@@ -0,0 +1,80 @@
+import * as libsignalModule from 'libsignal';
+import { logger } from './logger.js';
+
+const libsignal = libsignalModule.default || libsignalModule;
+
+if (libsignal?.SessionRecord?.prototype) {
+  libsignal.SessionRecord.prototype.closeSession = function (session) {
+    if (this.isClosed(session)) return;
+    session.indexInfo.closed = Date.now();
+  };
+
+  libsignal.SessionRecord.prototype.openSession = function (session) {
+    session.indexInfo.closed = -1;
+  };
+
+  libsignal.SessionRecord.prototype.removeOldSessions = function () {
+    while (Object.keys(this.sessions).length > 40) {
+      let oldestKey;
+      let oldestSession;
+      for (const [key, session] of Object.entries(this.sessions)) {
+        if (
+          session.indexInfo.closed !== -1 &&
+          (!oldestSession || session.indexInfo.closed < oldestSession.indexInfo.closed)
+        ) {
+          oldestKey = key;
+          oldestSession = session;
+        }
+      }
+      if (oldestKey) {
+        delete this.sessions[oldestKey];
+      } else {
+        throw new Error('Corrupt sessions object');
+      }
+    }
+  };
+
+  logger.debug('libsignal SessionRecord patches applied');
+} else {
+  logger.warn('libsignal SessionRecord patches skipped — target prototypes not found');
+}
+
+if (libsignal?.SessionBuilder?.prototype) {
+  libsignal.SessionBuilder.prototype.initIncoming = async function (record, message) {
+    const fqAddr = this.addr.toString();
+    if (!(await this.storage.isTrustedIdentity(fqAddr, message.identityKey))) {
+      throw new libsignal.UntrustedIdentityKeyError(this.addr.id, message.identityKey);
+    }
+    if (record.getSession(message.baseKey)) {
+      return;
+    }
+    const preKeyPair = await this.storage.loadPreKey(message.preKeyId);
+    if (message.preKeyId && !preKeyPair) {
+      throw new libsignal.PreKeyError('Invalid PreKey ID');
+    }
+    const signedPreKeyPair = await this.storage.loadSignedPreKey(message.signedPreKeyId);
+    if (!signedPreKeyPair) {
+      throw new libsignal.PreKeyError('Missing SignedPreKey');
+    }
+    const existingOpenSession = record.getOpenSession();
+    if (existingOpenSession) {
+      record.closeSession(existingOpenSession);
+    }
+    record.setSession(
+      await this.initSession(
+        false,
+        preKeyPair,
+        signedPreKeyPair,
+        message.identityKey,
+        message.baseKey,
+        undefined,
+        message.registrationId
+      )
+    );
+    return message.preKeyId;
+  };
+
+  logger.debug('libsignal SessionBuilder patches applied');
+} else {
+  logger.warn('libsignal SessionBuilder patches skipped — target prototypes not found');
+}

package/src/internals/logger.js

@@ -1,15 +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, pino };
+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, pino };