@shoru/kitten 0.0.6 → 0.1.0

package/src/client/constants.js

@@ -0,0 +1,41 @@
+import { DisconnectReason } from 'baileys';
+import { pino } from '#internals.js';
+
+export const ConnectionState = Object.freeze({
+  DISCONNECTED: 'disconnected',
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  RECONNECTING: 'reconnecting',
+});
+
+export const DISCONNECT_HANDLERS = new Map([
+  [DisconnectReason.connectionClosed, { message: 'Connection closed', recoverable: true }],
+  [DisconnectReason.restartRequired, { message: 'Restart required', recoverable: true, isRestart: 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: false, deleteSession: true }],
+  [DisconnectReason.connectionReplaced, { message: 'Connection replaced by another session', recoverable: false }],
+  [DisconnectReason.badSession, { message: 'Corrupted session', recoverable: false, deleteSession: true }],
+  [DisconnectReason.multideviceMismatch, { message: 'Multi-device mismatch', recoverable: false }],
+  [DisconnectReason.forbidden, { message: 'Account banned', recoverable: false, deleteSession: true }],
+  [405, { message: 'Not logged in', recoverable: false, deleteSession: true }],
+]);
+
+export const silentLogger = Object.freeze({
+  trace: () => {},
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  fatal: () => {},
+  prompt: () => {},
+  child: () => silentLogger,
+});
+
+export const silentPino = pino({ level: 'silent' });
+
+export const DEFAULT_MAX_RETRIES = 30;
+
+export const defaultBackoff = (attempt) => Math.min(1000 * 2 ** (attempt - 1), 60_000);
+

package/src/client/errors.js

@@ -0,0 +1,47 @@
+import { isBoom } from '@hapi/boom';
+import { DISCONNECT_HANDLERS } from './constants.js';
+
+export class ConnectionError extends Error {
+  constructor(message, { statusCode, recoverable = true } = {}) {
+    super(message);
+    this.name = 'ConnectionError';
+    this.statusCode = statusCode;
+    this.recoverable = recoverable;
+  }
+}
+
+export function parseDisconnectReason(lastDisconnect) {
+  const error = lastDisconnect?.error;
+  let statusCode = null;
+
+  if (isBoom(error)) {
+    statusCode = error.output?.statusCode;
+  } else if (error?.output?.statusCode) {
+    statusCode = error.output.statusCode;
+  } else if (typeof error?.statusCode === 'number') {
+    statusCode = error.statusCode;
+  }
+
+  if (!statusCode) {
+    return {
+      message: error?.message || 'Connection failure',
+      statusCode: 'NETWORK_ERROR',
+      recoverable: true,
+      deleteSession: false,
+    };
+  }
+
+  const handler = DISCONNECT_HANDLERS.get(statusCode);
+
+  if (!handler) {
+    return {
+      message: error?.message || `Unknown disconnect reason (code: ${statusCode})`,
+      statusCode,
+      recoverable: true,
+      deleteSession: false,
+    };
+  }
+
+  return { ...handler, statusCode };
+}
+

package/src/client/event-bus.js

@@ -0,0 +1,69 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Creates a lightweight, zero-latency persistent event bus for WASocket.
+ * Forwards Baileys events directly to subscribers with zero buffering overhead,
+ * maintaining persistent listener registrations across socket reconnections.
+ */
+export function createPersistentEventBus() {
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(0); // Unlimited listeners
+
+  return {
+    on(event, listener) {
+      emitter.on(event, listener);
+      return this;
+    },
+
+    off(event, listener) {
+      emitter.off(event, listener);
+      return this;
+    },
+
+    addListener(event, listener) {
+      emitter.addListener(event, listener);
+      return this;
+    },
+
+    removeListener(event, listener) {
+      emitter.removeListener(event, listener);
+      return this;
+    },
+
+    removeAllListeners(event) {
+      emitter.removeAllListeners(event);
+      return this;
+    },
+
+    emit(event, data) {
+      return emitter.emit(event, data);
+    },
+
+    process(handler) {
+      const listener = async (event, data) => {
+        try {
+          await handler({ [event]: data });
+        } catch {
+          /* noop */
+        }
+      };
+      emitter.on('event', listener);
+      return () => {
+        emitter.off('event', listener);
+      };
+    },
+
+    // Baileys buffer compatibility stubs (Baileys raw socket already handles buffering)
+    buffer() {},
+    flush() {
+      return false;
+    },
+    isBuffering() {
+      return false;
+    },
+    createBufferedFunction(work) {
+      return work;
+    },
+  };
+}
+

package/src/client/index.js

@@ -1,2 +1,9 @@
-export * from "./getConnectionConfig.js"
-export * from "./client.js"
+export * from './constants.js';
+export * from './errors.js';
+export * from './registry.js';
+export * from './socket-proxy.js';
+export * from './event-bus.js';
+export * from './auth-handler.js';
+export * from './sync-manager.js';
+export * from './getConnectionConfig.js';
+export * from './client.js';

package/src/client/registry.js

@@ -0,0 +1,63 @@
+const clients = new Map();
+
+let isSyncing = false;
+let isConfiguring = false;
+
+export const ClientRegistry = {
+  get(id) {
+    return clients.get(id);
+  },
+
+  has(id) {
+    return clients.has(id);
+  },
+
+  set(id, client) {
+    if (id != null) {
+      clients.set(id, client);
+    }
+  },
+
+  delete(id) {
+    if (id != null) {
+      clients.delete(id);
+    }
+  },
+
+  get size() {
+    return clients.size;
+  },
+
+  keys() {
+    return clients.keys();
+  },
+
+  values() {
+    return clients.values();
+  },
+
+  entries() {
+    return clients.entries();
+  },
+
+  [Symbol.iterator]() {
+    return clients.values();
+  },
+
+  get isSyncing() {
+    return isSyncing;
+  },
+
+  set isSyncing(val) {
+    isSyncing = Boolean(val);
+  },
+
+  get isConfiguring() {
+    return isConfiguring;
+  },
+
+  set isConfiguring(val) {
+    isConfiguring = Boolean(val);
+  },
+};
+

package/src/client/socket-proxy.js

@@ -0,0 +1,57 @@
+/**
+ * Creates a transparent proxy around the underlying WASocket instance.
+ * Intercepts the `ev` property to always return the persistent EventBuffer,
+ * ensuring all event listeners survive reconnections seamlessly.
+ *
+ * @param {() => any} getRawSock - Accessor for the active raw WASocket
+ * @param {() => any} getEv - Accessor for the persistent EventBuffer
+ * @returns {Proxy} The wrapped socket proxy
+ */
+export function createSocketProxy(getRawSock, getEv) {
+  return new Proxy({}, {
+    get(target, prop, receiver) {
+      if (prop === 'ev') {
+        return getEv();
+      }
+      const raw = getRawSock();
+      if (!raw) {
+        return undefined;
+      }
+      const value = Reflect.get(raw, prop, raw);
+      if (typeof value === 'function') {
+        return value.bind(raw);
+      }
+      return value;
+    },
+
+    set(target, prop, value, receiver) {
+      const raw = getRawSock();
+      if (raw) {
+        return Reflect.set(raw, prop, value, raw);
+      }
+      return true;
+    },
+
+    has(target, prop) {
+      if (prop === 'ev') return true;
+      const raw = getRawSock();
+      return raw ? Reflect.has(raw, prop) : false;
+    },
+
+    ownKeys(target) {
+      const raw = getRawSock();
+      const keys = raw ? Reflect.ownKeys(raw) : [];
+      if (!keys.includes('ev')) keys.push('ev');
+      return keys;
+    },
+
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === 'ev') {
+        return { enumerable: true, configurable: true, value: getEv() };
+      }
+      const raw = getRawSock();
+      return raw ? Reflect.getOwnPropertyDescriptor(raw, prop) : undefined;
+    }
+  });
+}
+

package/src/client/sync-manager.js

@@ -0,0 +1,79 @@
+import { listSessions } from '#auth.js';
+import { ClientRegistry } from './registry.js';
+
+/**
+ * Restores a specific session in the background.
+ *
+ * @param {string|number} sessionId - Session identifier to restore
+ * @param {any} ClientClass - The Client class constructor
+ * @returns {Promise<boolean>} True if restored, false if already active
+ */
+export async function restoreSession(sessionId, ClientClass) {
+  if (ClientRegistry.has(sessionId)) {
+    return false;
+  }
+
+  const client = new ClientClass({
+    id: sessionId,
+    silent: true,
+    sync: true,
+    maxRetries: 3,
+  });
+
+  await client.connect();
+  return true;
+}
+
+/**
+ * Synchronizes and restores all other existing sessions in the background.
+ *
+ * @param {object} params
+ * @param {string|number} params.currentId - The current active client session ID
+ * @param {string} params.flag - Logging tag
+ * @param {object} params.logger - Logger instance
+ * @param {any} params.ClientClass - The Client class constructor
+ */
+export async function syncOtherSessions({ currentId, flag, logger, ClientClass }) {
+  if (ClientRegistry.isSyncing) return;
+  ClientRegistry.isSyncing = true;
+
+  try {
+    const allSessionIds = listSessions();
+    const otherSessionIds = allSessionIds.filter((id) => id !== currentId);
+
+    if (otherSessionIds.length === 0) {
+      logger.debug(`[${flag}] No other sessions to sync`);
+      return;
+    }
+
+    logger.debug(
+      `[${flag}] Syncing ${otherSessionIds.length} other session(s) in background`
+    );
+
+    const results = await Promise.allSettled(
+      otherSessionIds.map((sessionId) => restoreSession(sessionId, ClientClass))
+    );
+
+    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++;
+      }
+    }
+
+    logger.debug(
+      `[${flag}] Session sync complete: ${successCount} restored, ${skipCount} skipped, ${failCount} failed`
+    );
+  } catch (err) {
+    logger.error(err, `[${flag}] Error during session sync`);
+  } finally {
+    ClientRegistry.isSyncing = false;
+  }
+}
+

package/src/config/default.js

@@ -1,39 +1,39 @@
-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,
-};
-
-const plugins = {
-  dir: 'plugins',
-  prefixes: ['.', '\\', '!'],
-  defaultEvent: 'messages.upsert',
-  hmr: {
-    enable: false,
-    debounce: 200,
-    debug: false
-  }
-}
-
-export default {
-  db,
-  socket,
-  plugins,
-  timeZone: 'Africa/Casablanca'
-}
+import { Browsers } from "baileys";
+import pino from "pino";
+
+const socket = {
+  browser: Browsers.ubuntu('Chrome'),
+  markOnlineOnConnect: false,
+  syncFullHistory: false,
+  generateHighQualityLinkPreview: false,
+  shouldIgnoreJid: () => false,
+  shouldSyncHistoryMessage: () => false,
+  logger: pino({ level: "silent" }),
+};
+
+const db = {
+  path: './db',
+  compression: true,
+  mapSize: 2 * 1024 * 1024 * 1024, // 2 GB
+  maxReaders: 126,
+  noSync: true,
+  noMetaSync: true,
+};
+
+const plugins = {
+  dir: 'plugins',
+  prefixes: ['.', '\\', '!'],
+  defaultEvent: 'messages.upsert',
+  hmr: {
+    enable: false,
+    debounce: 200,
+    debug: false,
+  },
+};
+
+export default {
+  db,
+  socket,
+  plugins,
+  timeZone: 'Africa/Casablanca',
+};