@shoru/kitten 0.0.6 → 0.1.0

package/internal-test/index.js

@@ -0,0 +1,4 @@
+import { logger, getClient } from '../src/index.js';
+
+logger.level = 'debug';
+await getClient();

package/internal-test/kittenwa.config.js

@@ -0,0 +1,33 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const pluginsDir = path.resolve(__dirname, 'plugins');
+
+const db = {
+  path: path.resolve(__dirname, '../db'),
+  compression: true,
+  mapSize: 2 * 1024 * 1024 * 1024, // 2 GB
+  maxReaders: 126,
+  noSync: false,
+  noMetaSync: false,
+};
+
+const plugins = {
+  dir: pluginsDir,
+  prefixes: ['.', '\\', '!'],
+  defaultEvent: 'messages.upsert',
+  hmr: {
+    enable: true,
+    debounce: 200,
+    debug: true
+  }
+}
+
+export default {
+  db,
+  plugins,
+  timeZone: 'Africa/Casablanca'
+}

package/internal-test/plugins/exp.js

@@ -0,0 +1,7 @@
+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 });
+}
+
+plugin.events = ['messages.upsert'];
+plugin.match = ['tst'];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shoru/kitten",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "A powerful Node.js framework to simplify making WhatsApp Bots",
   "main": "src/index.js",
   "repository": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "start": "node --no-warnings src/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --no-warnings internal-test/index.js"
   },
   "imports": {
     "#utils.js": "./src/utils/index.js",
@@ -26,16 +26,16 @@
   "license": "MIT",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
-    "@inquirer/prompts": "^8.1.0",
-    "@shoru/spindle": "^1.0.6",
+    "@inquirer/prompts": "^8.7.0",
+    "@shoru/spindle": "^1.0.7",
     "async-mutex": "^0.5.0",
-    "baileys": "^7.0.0-rc.9",
-    "chalk": "^5.6.2",
+    "baileys": "github:WhiskeySockets/Baileys",
+    "chalk": "^6.0.0",
     "chokidar": "^5.0.0",
-    "cosmiconfig": "^9.0.0",
-    "defu": "^6.1.4",
-    "lmdb": "^3.4.4",
-    "pino": "^10.1.0",
+    "cosmiconfig": "^10.0.0",
+    "defu": "^6.1.7",
+    "lmdb": "^3.5.6",
+    "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "qrcode-terminal": "^0.12.0"
   }

package/src/auth/init-session.js

@@ -1,19 +1,32 @@
-import { makeWASocket } from "baileys";
+import { makeWASocket, fetchLatestWaWebVersion } from "baileys";
 import { useLMDBAuthState } from "./lmdb-auth-state.js";
 import { getConfig } from "#internals.js";
 
 const config = await getConfig();
+let cachedWaVersion = null;
+
+const getWaVersion = async () => {
+  if (!cachedWaVersion) {
+    try {
+      const { version } = await fetchLatestWaWebVersion();
+      cachedWaVersion = version;
+    } catch {/* noop */}
+  }
+  return cachedWaVersion;
+};
 
 export const initSession = async ({ socketConfig, id } = {}) => {
   try {
     const { state, saveCreds, session } = await useLMDBAuthState(id);
-  
-    const sock = makeWASocket({ 
+    const version = (await getWaVersion()) || config.socket?.version;
+
+    const sock = makeWASocket({
+      version: version || undefined,
       auth: state,
-      ...config.socket, 
+      ...config.socket,
       ...socketConfig
     });
-  
+
     sock.ev.on("creds.update", saveCreds);
 
     return { sock, session };

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

@@ -1,177 +1,271 @@
-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) => {
-  const id = (db.get(COUNTER_KEY) ?? 0) + 1;
-  await 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 existingCreds = db.get(keys.creds);
-  let creds;
-  
-  if (existingCreds != null) {
-    creds = deserialize(existingCreds);
-  } else {
-    creds = initAuthCreds();
-    await db.put(keys.creds, serialize(creds));
-    await db.put(`${SESSION_PREFIX}${sessionId}`, true);
-  }
-
-  const writeCreds = async (credsData) => {
-    await db.put(keys.creds, serialize(credsData));
-  };
-
-  const getKeys = (type, ids) => {
-    if (!ids.length) return {};
-
-    const result = {};
-    for (const id of ids) {
-      const dbKey = keys.forKey(type, id);
-      const rawValue = db.get(dbKey);
-
-      if (rawValue != null) {
-        try {
-          let parsed = deserialize(rawValue);
-          if (type === "app-state-sync-key" && parsed) {
-            parsed = proto.Message.AppStateSyncKeyData.fromObject(parsed);
-          }
-          result[id] = parsed;
-        } catch (err) {
-          logger.error(
-            err,
-            `[LMDBAuthState] Deserialize error: ${type}:${id}`
-          );
-          result[id] = null;
-        }
-      } else {
-        result[id] = null;
-      }
-    }
-    return result;
-  };
-
-  const setKeys = async (data) => {
-    const writes = [];
-    
-    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) {
-          writes.push(db.put(key, serialize(value)));
-        } else {
-          writes.push(db.remove(key));
-        }
-      }
-    }
-    
-    if (writes.length > 0) {
-      await Promise.all(writes);
-    }
-  };
-
-  const clearKeys = async () => {
-    let count = 0;
-    const writes = [];
-    
-    for (const { key } of db.getRange({
-      start: keys.sessionPrefix,
-      end: `${keys.sessionPrefix}\xFF`,
-    })) {
-      if (key !== keys.creds) {
-        writes.push(db.remove(key));
-        count++;
-      }
-    }
-    
-    if (writes.length > 0) {
-      await Promise.all(writes);
-    }
-    logger.debug(`[LMDBAuthState] Cleared ${count} keys`);
-  };
-
-  const deleteSession = async () => {
-    const writes = [];
-    
-    for (const { key } of db.getRange({
-      start: keys.sessionPrefix,
-      end: `${keys.sessionPrefix}\xFF`,
-    })) {
-      writes.push(db.remove(key));
-    }
-    writes.push(db.remove(`${SESSION_PREFIX}${sessionId}`));
-    
-    await Promise.all(writes);
-    logger.debug(`[LMDBAuthState] Deleted session ${sessionId}`);
-  };
-
-  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;
+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) => {
+  const current = db.get(COUNTER_KEY);
+  let id;
+  if (current == null) {
+    const existing = listSessions();
+    id = existing.length > 0 ? Math.max(...existing) + 1 : 0;
+  } else {
+    id = current + 1;
+  }
+  await db.put(COUNTER_KEY, id);
+  return id;
+};
+
+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;
+  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 existingCreds = db.get(keys.creds);
+  let creds = null;
+  let isNew = false;
+
+  if (existingCreds != null) {
+    try {
+      creds = deserialize(existingCreds);
+    } catch {
+      logger.warn(`[LMDBAuthState] Corrupted credentials for session ${sessionId}, purging session`);
+      creds = null;
+    }
+
+    if (creds && (creds.registered || creds.me)) {
+      await db.put(`${SESSION_PREFIX}${sessionId}`, true);
+    } else {
+      // Credentials not registered or corrupted: clean up old session keys and start fresh
+      for (const { key } of db.getRange({
+        start: keys.sessionPrefix,
+        end: `${keys.sessionPrefix}\xFF`,
+      })) {
+        await db.remove(key);
+      }
+      await db.remove(`${SESSION_PREFIX}${sessionId}`);
+      creds = initAuthCreds();
+      await db.put(keys.creds, serialize(creds));
+      isNew = true;
+    }
+  } else {
+    creds = initAuthCreds();
+    await db.put(keys.creds, serialize(creds));
+    isNew = true;
+  }
+
+  const writeCreds = async (credsData) => {
+    await db.put(keys.creds, serialize(credsData));
+    if (credsData?.registered || credsData?.me) {
+      await db.put(`${SESSION_PREFIX}${sessionId}`, true);
+    }
+  };
+
+  const getKeys = (type, ids) => {
+    if (!ids.length) return {};
+
+    const result = {};
+    for (const id of ids) {
+      const dbKey = keys.forKey(type, id);
+      const rawValue = db.get(dbKey);
+
+      if (rawValue != null) {
+        try {
+          let parsed = deserialize(rawValue);
+          if (type === "app-state-sync-key" && parsed) {
+            parsed = proto.Message.AppStateSyncKeyData.fromObject(parsed);
+          }
+          result[id] = parsed;
+        } catch (err) {
+          logger.error(
+            err,
+            `[LMDBAuthState] Deserialize error: ${type}:${id}`
+          );
+          result[id] = null;
+        }
+      } else {
+        result[id] = null;
+      }
+    }
+    return result;
+  };
+
+  const setKeys = async (data) => {
+    const writes = [];
+
+    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) {
+          writes.push(db.put(key, serialize(value)));
+        } else {
+          writes.push(db.remove(key));
+        }
+      }
+    }
+
+    if (writes.length > 0) {
+      await Promise.all(writes);
+    }
+  };
+
+  const clearKeys = async () => {
+    let count = 0;
+    const writes = [];
+
+    for (const { key } of db.getRange({
+      start: keys.sessionPrefix,
+      end: `${keys.sessionPrefix}\xFF`,
+    })) {
+      if (key !== keys.creds) {
+        writes.push(db.remove(key));
+        count++;
+      }
+    }
+
+    if (writes.length > 0) {
+      await Promise.all(writes);
+    }
+    logger.debug(`[LMDBAuthState] Cleared ${count} keys`);
+  };
+
+  const deleteSession = async () => {
+    const writes = [];
+
+    for (const { key } of db.getRange({
+      start: keys.sessionPrefix,
+      end: `${keys.sessionPrefix}\xFF`,
+    })) {
+      writes.push(db.remove(key));
+    }
+    writes.push(db.remove(`${SESSION_PREFIX}${sessionId}`));
+
+    await Promise.all(writes);
+    logger.debug(`[LMDBAuthState] Deleted session ${sessionId}`);
+  };
+
+  return {
+    state: {
+      creds,
+      keys: {
+        get: getKeys,
+        set: setKeys,
+        clear: clearKeys,
+      },
+    },
+    saveCreds: () => writeCreds(creds),
+    session: {
+      delete: deleteSession,
+      clear: clearKeys,
+      id: sessionId,
+      isNew,
+    },
+  };
+}
+
+export function listSessions() {
+  const { db } = LMDBManager;
+  if (!db) return [];
+
+  const sessions = new Set();
+
+  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)) {
+      const rawCreds = db.get(`${KEY_PREFIX}:${id}:creds`);
+      if (rawCreds != null) {
+        try {
+          const creds = deserialize(rawCreds);
+          if (creds?.registered || creds?.me) {
+            sessions.add(id);
+          } else {
+            db.remove(key);
+          }
+        } catch {
+          db.remove(key);
+        }
+      } else {
+        db.remove(key);
+      }
+    }
+  }
+
+  // Also check for existing credentials as fallback
+  for (const { key, value } of db.getRange({
+    start: `${KEY_PREFIX}:`,
+    end: `${KEY_PREFIX}:\xFF`,
+  })) {
+    if (key.endsWith(':creds')) {
+      const parts = key.split(':');
+      if (parts.length === 3 && parts[0] === KEY_PREFIX && parts[2] === 'creds') {
+        const id = parseInt(parts[1], 10);
+        if (!isNaN(id) && !sessions.has(id)) {
+          try {
+            const creds = deserialize(value);
+            if (creds?.registered || creds?.me) {
+              sessions.add(id);
+              db.put(`${SESSION_PREFIX}${id}`, true);
+            }
+          } catch {
+            /* ignore corrupted creds */
+          }
+        }
+      }
+    }
+  }
+
+  return [...sessions].sort((a, b) => a - b);
+}
+
+export function sessionExists(sessionId) {
+  if (!Number.isInteger(sessionId) || sessionId < 0) return false;
+  const { db } = LMDBManager;
+  if (!db) return false;
+
+  const rawCreds = db.get(`${KEY_PREFIX}:${sessionId}:creds`);
+  if (rawCreds != null) {
+    try {
+      const creds = deserialize(rawCreds);
+      if (creds?.registered || creds?.me) {
+        db.put(`${SESSION_PREFIX}${sessionId}`, true);
+        return true;
+      }
+    } catch {
+      db.remove(`${SESSION_PREFIX}${sessionId}`);
+      return false;
+    }
+  }
+  db.remove(`${SESSION_PREFIX}${sessionId}`);
+  return false;
 }

package/src/client/auth-handler.js

@@ -0,0 +1,97 @@
+import qrcode from 'qrcode-terminal';
+import chalk from 'chalk';
+import { ConnectionError } from './errors.js';
+import { ClientRegistry } from './registry.js';
+import { getConnectionConfig } from './getConnectionConfig.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,
+  flag,
+  isSync,
+  isSilent,
+  onPairing,
+  logger,
+  authConfig,
+  setAuthConfig,
+  pairingCodeRequested,
+  setPairingCodeRequested,
+  onSyncAuthAbort,
+}) {
+  if (isSync) {
+    const err = new ConnectionError('Authentication required for sync connection', {
+      recoverable: false,
+    });
+    logger.debug(`[${flag}] Sync connection requires auth, aborting`);
+    onSyncAuthAbort(err);
+    return;
+  }
+
+  if (ClientRegistry.isConfiguring) return;
+
+  if (typeof onPairing === 'function') {
+    const requestPairingCode = rawSock?.requestPairingCode?.bind(rawSock);
+    await onPairing({ qr, requestPairingCode });
+    return;
+  }
+
+  if (isSilent) {
+    return;
+  }
+
+  let currentAuthConfig = authConfig;
+  if (!currentAuthConfig) {
+    ClientRegistry.isConfiguring = true;
+    try {
+      currentAuthConfig = await getConnectionConfig();
+      setAuthConfig(currentAuthConfig);
+    } finally {
+      ClientRegistry.isConfiguring = false;
+    }
+  }
+
+  if (currentAuthConfig.type === 'pn') {
+    if (!pairingCodeRequested && rawSock) {
+      try {
+        setPairingCodeRequested(true);
+        const code = await rawSock.requestPairingCode(currentAuthConfig.pn);
+        logger.prompt(formatPairingCode(code));
+      } catch (err) {
+        setPairingCodeRequested(false);
+        logger.error(err, `[${flag}] Failed to request pairing code`);
+      }
+    }
+  } else {
+    qrcode.generate(qr, { small: true });
+    process.stdout.write('\n');
+  }
+}
+