@shoru/kitten 0.0.1 → 0.0.2

package/src/client/client.js

@@ -1,11 +1,10 @@
-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";
+import { DisconnectReason } from 'baileys';
+import { Boom } from '@hapi/boom';
+import qrcode from 'qrcode-terminal';
+import chalk from 'chalk';
+import { logger, pino, pluginManager } from '#internals.js';
+import { initSession, listSessions } from '#auth.js';
+import { getConnectionConfig } from './getConnectionConfig.js';
 
 export const ConnectionState = Object.freeze({
   DISCONNECTED: 'disconnected',
@@ -17,33 +16,83 @@ export const ConnectionState = Object.freeze({
 class ConnectionError extends Error {
   constructor(message, { statusCode, recoverable = true } = {}) {
     super(message);
-    this.name = "ConnectionError";
+    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 }],
+  [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 }],
 ]);
 
+const silentLogger = Object.freeze({
+  trace: () => {},
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  fatal: () => {},
+  prompt: () => {},
+  child: () => silentLogger,
+});
+
+const silentPino = pino({ level: 'silent' });
+
 export class Client {
+  static #registry = new Map();
+
+  static #isSyncing = false;
+  static #isConfiguring = false;
+
+  // Static Registry API
+
+  static get(id) {
+    return Client.#registry.get(id);
+  }
+
+  static has(id) {
+    return Client.#registry.has(id);
+  }
+
+  static get size() {
+    return Client.#registry.size;
+  }
+
+  static keys() {
+    return Client.#registry.keys();
+  }
+
+  static values() {
+    return Client.#registry.values();
+  }
+  
+  static entries() {
+    return Client.#registry.entries();
+  }
+
+  static [Symbol.iterator]() {
+    return Client.#registry.values();
+  }
+
+  // Instance Properties
+
   sock = null;
   session = null;
   id = null;
 
-  #flag = "";
+  #flag = '';
+  #plugins = null;
   #qr = null;
   #state = ConnectionState.DISCONNECTED;
-  #cancelWait
-  #isConfiguring = false;
+  #cancelWait = null;
   #hasConnectedOnce = false;
 
   #socketConfig = null;
@@ -58,6 +107,12 @@ export class Client {
   #maxRetries;
   #backoff;
 
+  // Options
+  #silent;
+  #sync;
+  #logger;
+
+  // Callbacks
   #onPairing;
   #onConnect;
   #onReconnect;
@@ -68,19 +123,24 @@ export class Client {
     const {
       id,
       maxRetries = 30,
-      backoff = (attempt) => Math.min(1000 * Math.pow(2, attempt - 1), 60_000),
+      backoff = (attempt) => Math.min(1000 * 2 ** (attempt - 1), 60_000),
+      silent = false,
+      sync = false,
       onPairing = null,
       onConnect = null,
       onReconnect = null,
       onDisconnect = null,
       onStateChange = null,
-      socketConfig = {}
+      socketConfig = {},
     } = options;
 
     this.id = id;
     this.#socketConfig = socketConfig;
     this.#maxRetries = maxRetries;
     this.#backoff = backoff;
+    this.#silent = silent;
+    this.#sync = sync;
+    this.#logger = silent ? silentLogger : logger;
     this.#onPairing = onPairing;
     this.#onConnect = onConnect;
     this.#onReconnect = onReconnect;
@@ -100,6 +160,20 @@ export class Client {
     return this.#reconnectAttempts;
   }
 
+  // Registry Management
+
+  #register() {
+    if (this.id != null) {
+      Client.#registry.set(this.id, this);
+    }
+  }
+
+  #unregister() {
+    if (this.id != null) {
+      Client.#registry.delete(this.id);
+    }
+  }
+
   // State Management
 
   #setState(newState) {
@@ -125,7 +199,7 @@ export class Client {
       try {
         callback({ ...data, client: this });
       } catch (err) {
-        logger.error(err, `[${this.#flag}] Error in ${event} callback`);
+        this.#logger.error(err, `[${this.#flag}] Error in ${event} callback`);
       }
     });
   }
@@ -151,7 +225,6 @@ export class Client {
   async #initConnection() {
     this.#setState(ConnectionState.CONNECTING);
     this.#reconnectAttempts = 0;
-
     this.#pendingConnect = this.#createDeferred();
 
     try {
@@ -189,8 +262,12 @@ export class Client {
   async #createSocket() {
     this.#cleanupSocket();
 
+    const socketConfig = this.#silent
+      ? { ...this.#socketConfig, logger: silentPino }
+      : this.#socketConfig;
+
     const { sock, session } = await initSession({
-      socketConfig: this.#socketConfig,
+      socketConfig,
       id: this.id,
     });
 
@@ -199,7 +276,7 @@ export class Client {
     this.id = session.id;
     this.#flag = `CLIENT-${session.id}`;
 
-    this.sock.ev.on("connection.update", (update) => {
+    this.sock.ev.on('connection.update', (update) => {
       this.#handleConnectionUpdate(update);
     });
   }
@@ -210,54 +287,131 @@ export class Client {
     try {
       if (qr) {
         await this.#handleAuth(qr);
-      } else if (connection === "open") {
-        this.#onConnectionOpen();
-      } else if (connection === "close") {
+      } else if (connection === 'open') {
+        await this.#onConnectionOpen();
+      } else if (connection === 'close') {
         await this.#onConnectionClose(lastDisconnect);
       }
     } catch (err) {
-      logger.error(err, `[${this.#flag}] Error in connection update handler`);
+      this.#logger.error(err, `[${this.#flag}] Error in connection update handler`);
       this.#resolvePending(null, err);
     }
   }
 
-  #onConnectionOpen() {
+  async #onConnectionOpen() {
     const wasReconnecting = this.#state === ConnectionState.RECONNECTING;
     this.#setState(ConnectionState.CONNECTED);
 
+    this.#register();
+
+    if (!this.#plugins || this.#plugins.destroyed) {
+      try {
+        this.#plugins = await pluginManager(this.sock);
+      } catch (err) {
+        this.#logger.error(err, `[${this.#flag}] Failed to initialize plugins`);
+      }
+    }
+
     const attempts = this.#reconnectAttempts;
     this.#reconnectAttempts = 0;
 
     if (wasReconnecting) {
       this.#emit('reconnect', { attempts });
-      logger.debug(`[${this.#flag}] Reconnected after ${attempts} attempt(s)`);
+      this.#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 });
+      this.#logger.debug(`[${this.#flag}] Connected successfully`);
+      this.#resolvePending({ sock: this.sock, session: this.session, id: this.id });
+
+      if (!this.#sync) {
+        this.#syncOtherSessions();
+      }
     }
   }
 
+  // Automatic Session Synchronization
+
+  async #syncOtherSessions() {
+    if (Client.#isSyncing) return;
+    Client.#isSyncing = true;
+
+    try {
+      const allSessionIds = listSessions();
+      const otherSessionIds = allSessionIds.filter((id) => id !== this.id);
+
+      if (otherSessionIds.length === 0) {
+        this.#logger.debug(`[${this.#flag}] No other sessions to sync`);
+        return;
+      }
+
+      this.#logger.debug(
+        `[${this.#flag}] Syncing ${otherSessionIds.length} other session(s) in background`
+      );
+
+      const results = await Promise.allSettled(
+        otherSessionIds.map((sessionId) => this.#restoreSession(sessionId))
+      );
+
+      let successCount = 0;
+      let skipCount = 0;
+      let failCount = 0;
+
+      for (const result of results) {
+        if (result.status === 'fulfilled') {
+          if (result.value === true) successCount++;
+          else skipCount++;
+        } else {
+          failCount++;
+        }
+      }
+
+      this.#logger.debug(
+        `[${this.#flag}] Session sync complete: ${successCount} restored, ${skipCount} skipped, ${failCount} failed`
+      );
+    } catch (err) {
+      this.#logger.error(err, `[${this.#flag}] Error during session sync`);
+    } finally {
+      Client.#isSyncing = false;
+    }
+  }
+
+  async #restoreSession(sessionId) {
+    if (Client.has(sessionId)) {
+      return false;
+    }
+
+    const client = new Client({
+      id: sessionId,
+      silent: true,
+      sync: true,
+      maxRetries: 3,
+    });
+
+    await client.connect();
+    return true;
+  }
+
   async #onConnectionClose(lastDisconnect) {
     const disconnectInfo = this.#parseDisconnectReason(lastDisconnect);
     const { message, statusCode, recoverable, deleteSession } = disconnectInfo;
 
-    if (message === "QR Scanned" && !this.#onPairing) {
+    if (message === 'QR Scanned' && !this.#onPairing && !this.#silent) {
       console.clear();
     }
 
     const level = recoverable ? 'debug' : 'warn';
-
-    logger[level](`[${this.#flag}] Disconnected: ${message} (code: ${statusCode})`);
+    this.#logger[level](`[${this.#flag}] Disconnected: ${message} (code: ${statusCode})`);
 
     if (this.#hasConnectedOnce) {
       this.#emit('disconnect', { message, statusCode, recoverable });
     }
+    
+    this.#unregister();
 
     if (deleteSession) {
       await this.session?.delete().catch((err) => {
-        logger.error(err, `[${this.#flag}] Failed to delete session`);
+        this.#logger.error(err, `[${this.#flag}] Failed to delete session`);
       });
     }
 
@@ -282,7 +436,7 @@ export class Client {
       );
       this.#setState(ConnectionState.DISCONNECTED);
       this.#resolvePending(null, err);
-      logger.error(err, `[${this.#flag}] ${err.message}`);
+      this.#logger.error(err, `[${this.#flag}] ${err.message}`);
       return;
     }
 
@@ -291,20 +445,22 @@ export class Client {
     }
 
     const delay = this.#backoff(this.#reconnectAttempts);
+    const retriesInfo =
+      this.#maxRetries !== Infinity
+        ? `(${this.#reconnectAttempts}/${this.#maxRetries})`
+        : '';
 
-    const retriesInfo = this.#maxRetries !== Infinity ? `(${this.#reconnectAttempts}/${this.#maxRetries})` : '';
-
-    logger.debug(`[${this.#flag}] ${reason}. Reconnecting in ${delay} ms`);
+    this.#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}`);
+    this.#logger.debug(`[${this.#flag}] Executing reconnect attempt ${retriesInfo}`);
 
     try {
       await this.#createSocket();
     } catch (err) {
-      logger.error(err, `[${this.#flag}] Socket creation failed during reconnect`);
+      this.#logger.error(err, `[${this.#flag}] Socket creation failed during reconnect`);
     }
   }
 
@@ -340,7 +496,19 @@ export class Client {
 
   async #handleAuth(qr) {
     this.#qr = qr;
-    if (this.#isConfiguring) return;
+
+    if (this.#sync) {
+      const err = new ConnectionError('Authentication required for sync connection', {
+        recoverable: false,
+      });
+      this.#logger.debug(`[${this.#flag}] Sync connection requires auth, aborting`);
+      this.#cleanupSocket();
+      this.#setState(ConnectionState.DISCONNECTED);
+      this.#resolvePending(null, err);
+      return;
+    }
+
+    if (Client.#isConfiguring) return;
 
     if (typeof this.#onPairing === 'function') {
       const requestPairingCode = this.sock?.requestPairingCode?.bind(this.sock);
@@ -348,32 +516,46 @@ export class Client {
       return;
     }
 
-    this.#isConfiguring = true;
-    this.#authConfig ??= await pauseSpinner(getConnectionConfig);
-    this.#isConfiguring = false;
+    if (this.#silent) {
+      return;
+    }
+
+    Client.#isConfiguring = true;
+    try {
+      this.#authConfig ??= await getConnectionConfig();
+    } finally {
+      Client.#isConfiguring = false;
+    }
 
-    if (this.#authConfig.type === "pn") {
+    if (this.#authConfig.type === 'pn') {
       const code = await this.sock.requestPairingCode(this.#authConfig.pn);
-      logger.prompt(this.#formatPairingCode(code));
+      this.#logger.prompt(this.#formatPairingCode(code));
     } else {
       qrcode.generate(this.#qr, { small: true });
-      process.stdout.write("\n");
+      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)}`;
+    const formatted = code.match(/.{1,4}/g)?.join(' ') ?? code;
+    return `\n${chalk.green('> Your OTP Code: ')}${chalk.bold(formatted)}`;
   }
 
   // Cleanup & Shutdown
 
   #cleanupSocket() {
+    if (this.#plugins && !this.#plugins.destroyed) {
+      this.#plugins.destroy();
+      this.#plugins = null;
+    }
+
     if (!this.sock) return;
 
     try {
       this.sock.ev.removeAllListeners();
-    } catch { /* noop */ };
+    } catch {
+      /* noop */
+    }
 
     this.sock = null;
   }
@@ -393,6 +575,9 @@ export class Client {
     this.#clearReconnectTimer();
     this.#resolvePending(null, new Error('Client disconnected'));
 
+    // Unregister from registry
+    this.#unregister();
+
     this.#cleanupSocket();
     this.#setState(ConnectionState.DISCONNECTED);
 
@@ -406,7 +591,7 @@ export class Client {
       await this.disconnect();
       await this.session?.delete();
     } catch (err) {
-      logger.error(err, `[${this.#flag}] Logging out failed: ${err.message}`)
+      this.#logger.error(err, `[${this.#flag}] Logging out failed`);
     }
   }
 }

package/src/client/getConnectionConfig.js

@@ -1,8 +1,9 @@
 import { select, input } from "@inquirer/prompts";
 import chalk from "chalk";
 import { logger } from "#internals.js";
+import { pauseSpinner } from "#utils.js";
 
-export const getConnectionConfig = async () => {
+const connectionConfig = async () => {
   try {
     process.stdout.write("\n");
     const type = await select({
@@ -45,4 +46,6 @@ export const getConnectionConfig = async () => {
       logger.prompt(chalk.red("\nOperation cancelled"));
       process.exit(0);
   }
-};
+};
+
+export const getConnectionConfig = () => pauseSpinner(connectionConfig);

package/src/config/default.js

@@ -20,7 +20,20 @@ const db = {
   noMetaSync: false,
 };
 
+const plugins = {
+  dir: 'plugins',
+  prefixes: ['.', '\\', '!'],
+  defaultEvent: 'messages.upsert',
+  hmr: {
+    enable: false,
+    debounce: 200,
+    debug: false
+  }
+}
+
 export default {
   db,
-  socket
+  socket,
+  plugins,
+  timeZone: 'Africa/Casablanca'
 }

package/src/formatter/format-message.js

@@ -0,0 +1,144 @@
+import {
+  isJidGroup, 
+  areJidsSameUser,
+  getDevice,
+  downloadMediaMessage,
+  getContentType,
+  isLidUser,
+  jidNormalizedUser
+ } from 'baileys';
+
+import {
+  getTimeString,
+  isString,
+  toNumber,
+  toBase64,
+  getPN
+} from '#utils.js';
+
+const extractMessage = (message) => {
+  let type = getContentType(message);
+  let data = message?.[type];
+
+  // cases like viewonce or document messages etc
+  if (data?.message) {
+    const innerType = getContentType(data.message);
+    if (innerType) {
+      type = innerType;
+      data = data.message[type];
+    }
+  }
+  return [type, data];
+};
+
+const extractContent = (message = {}) => ({
+    body: message.text ?? message.caption ??
+      (isString(message) ? message : undefined),
+    mentions: message.contextInfo?.mentionedJid,
+    groupMentions: message.contextInfo?.groupMentions,
+    mimetype: message.mimetype,
+    fileName: message.fileName,
+    pageCount: message.pageCount,
+    fileLength: toNumber(message.fileLength),
+    hash: toBase64(message.fileSha256),
+    isViewOnce: message.viewOnce,
+    url: message.matchedText,
+    description: message.description,
+    thumbnail: message.jpegThumbnail,
+});
+
+const load = async (x) => downloadMediaMessage(x, 'buffer', {});
+
+export const formatMessage = (sock, raw) => {
+  const myId = jidNormalizedUser(sock.user.lid);
+  const [type, messageData] = extractMessage(raw.message);
+
+  const {
+    pushName: name,
+    messageTimestamp,
+    participant: p1,
+    broadcast,
+    key,
+    key: {
+      remoteJid: roomId, 
+      id, fromMe,
+      participant: p2,
+    }
+  } = raw;
+
+  const jid = fromMe ? myId : p2 || p1 || roomId;
+
+  const {
+    quotedMessage,
+    participant: quotedSender,
+    stanzaId: quotedId,
+    isForwarded,
+    forwardingScore,
+  } = messageData?.contextInfo || {};
+  const [quotedType, quotedData] = extractMessage(quotedMessage);
+
+  const quotedKey = {
+    id: quotedId,
+    participant: quotedSender,
+    remoteJid: roomId,
+    fromMe: areJidsSameUser(quotedSender, myId)
+  };
+
+  return {
+    type,
+    name,
+    id,
+    broadcast,
+    isForwarded,
+    forwardingScore,
+    fromMe,
+    jid,
+    roomId,
+    timestamp: toNumber(messageTimestamp),
+    isLid: isLidUser(jid),
+    device: getDevice(id),
+    isGroup: isJidGroup(roomId),
+    timeString: getTimeString(messageTimestamp),
+    ...extractContent(messageData),
+    key, raw,
+    contextInfo: {
+      stanzaId: id,
+      participant: jid,
+      remoteJid: roomId
+    },
+    load() {
+      return load(this.raw)
+    },
+    senderIs(id) {
+      return areJidsSameUser(this.jid, id)
+    },
+    pn() {
+      return getPN(sock, this.jid)
+    },
+    quoted: quotedData ? {
+      type: quotedType,
+      jid: quotedSender,
+      id: quotedId,
+      ...extractContent(quotedData),
+      key: quotedKey,
+      contextInfo: {
+        stanzaId: quotedId,
+        participant: quotedSender,
+        remoteJid: roomId
+      },
+      raw: {
+        key: quotedKey,
+        message: quotedMessage
+      },
+      load() {
+        return load(this.raw)
+      },
+      senderIs(id) {
+        return areJidsSameUser(this.jid, id)
+      },
+      pn() {
+        return getPN(sock, this.jid)
+      }
+    }: undefined,
+  }
+}

package/src/formatter/index.js

@@ -0,0 +1,14 @@
+import { formatMessage } from './format-message.js';
+
+export const formatter = (wa, event, eventName) => {
+  eventName ??= 'messages.upsert';
+  
+  switch (eventName) {
+    case 'messages.upsert':
+      return {
+        ...formatMessage(wa, event),
+        event: eventName
+      };
+    default: return event;
+  }
+}

package/src/index.js

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