libzapitu 1.0.0-alpha.16 → 1.0.0-alpha.18

package/lib/worker/child.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/child.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Worker child entry point.
+ * Runs makeWASocket inside a worker_threads context and bridges all
+ * method calls and events between the parent and the WA socket.
+ *
+ * Supports multiple concurrent sockets per worker — each identified
+ * by a unique `socketId` sent in the `init` message from the parent.
+ */
+const worker_threads_1 = require("worker_threads");
+const Socket_1 = __importDefault(require("../Socket"));
+// ---------------------------------------------------------------------------
+// Ensure we never run this in the main thread
+// ---------------------------------------------------------------------------
+if (worker_threads_1.isMainThread || !worker_threads_1.parentPort) {
+    throw new Error('This file must be run as a Worker (worker_threads).');
+}
+// ---------------------------------------------------------------------------
+// Per-socket state
+// ---------------------------------------------------------------------------
+const CALLBACK_PROXIED_KEYS = [
+    'getMessage',
+    'shouldIgnoreJid',
+    'patchMessageBeforeSending',
+    'cachedGroupMetadata',
+    'shouldSyncHistoryMessage',
+    'makeSignalRepository',
+];
+const sockets = new Map();
+let _reqId = 0;
+const nextReqId = () => ++_reqId;
+// ---------------------------------------------------------------------------
+// Callback proxy helper
+// ---------------------------------------------------------------------------
+function proxyCallback(socketId, key, ...args) {
+    const id = nextReqId();
+    return new Promise((resolve, reject) => {
+        const onMsg = (msg) => {
+            if ((msg === null || msg === void 0 ? void 0 : msg.type) === 'callback-result' && msg.id === id && msg.socketId === socketId) {
+                worker_threads_1.parentPort.off('message', onMsg);
+                if (msg.error) {
+                    reject(new Error(msg.error));
+                }
+                else {
+                    resolve(msg.result);
+                }
+            }
+        };
+        worker_threads_1.parentPort.on('message', onMsg);
+        worker_threads_1.parentPort.postMessage({ type: 'callback-call', socketId, id, key, args });
+    });
+}
+// ---------------------------------------------------------------------------
+// Create a socket for a given socketId
+// ---------------------------------------------------------------------------
+function createSocket(socketId, rawConfig) {
+    const config = rawConfig;
+    // Replace sentinel callbacks with forwarding stubs
+    for (const k of CALLBACK_PROXIED_KEYS) {
+        if (config[k] === '__proxy_callback__') {
+            ;
+            config[k] = (...args) => proxyCallback(socketId, k, ...args);
+        }
+    }
+    const sock = (0, Socket_1.default)(config);
+    sock.ev.on('event', (map) => {
+        for (const [event, data] of Object.entries(map)) {
+            worker_threads_1.parentPort.postMessage({ type: 'event', socketId, event, data });
+        }
+    });
+    sockets.set(socketId, { sock, config });
+}
+// ---------------------------------------------------------------------------
+// Handle incoming messages from the parent
+// ---------------------------------------------------------------------------
+worker_threads_1.parentPort.on('message', async (msg) => {
+    if (!msg || typeof msg !== 'object')
+        return;
+    switch (msg.type) {
+        // --- Initialize a new socket on this worker ---
+        case 'init': {
+            const { socketId, config } = msg;
+            if (sockets.has(socketId)) {
+                // Already initialized — ignore duplicate
+                return;
+            }
+            createSocket(socketId, config);
+            break;
+        }
+        // --- RPC method call ---
+        case 'call': {
+            const { socketId, id, method, args } = msg;
+            const entry = sockets.get(socketId);
+            if (!entry) {
+                worker_threads_1.parentPort.postMessage({
+                    type: 'result',
+                    socketId,
+                    id,
+                    error: `Socket ${socketId} not found`,
+                });
+                return;
+            }
+            try {
+                let target = entry.sock;
+                const path = method.split('.');
+                for (const segment of path) {
+                    if (target === null || target === undefined) {
+                        throw new Error(`Cannot read property '${segment}' of ${target}`);
+                    }
+                    target = target[segment];
+                }
+                if (typeof target === 'function') {
+                    const thisCtx = path.length > 1 ? resolveTarget(entry.sock, path.slice(0, -1)) : entry.sock;
+                    const result = await target.apply(thisCtx, args || []);
+                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result });
+                }
+                else {
+                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result: target });
+                }
+            }
+            catch (err) {
+                worker_threads_1.parentPort.postMessage({
+                    type: 'result',
+                    socketId,
+                    id,
+                    error: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                });
+            }
+            break;
+        }
+    }
+});
+/**
+ * Walk a dot-separated path on the socket to resolve a nested target
+ * (used as `this` context for method calls).
+ */
+function resolveTarget(obj, path) {
+    let t = obj;
+    for (const seg of path) {
+        t = t[seg];
+    }
+    return t;
+}

package/lib/worker/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worker entry point — encapsulated mode.
+ *
+ * Import from here to run makeWASocket inside a child worker_threads
+ * process instead of the main thread.  Multiple sockets are automatically
+ * distributed across a pool of workers (default: CPU count).
+ *
+ * @example
+ *   import makeWASocket from 'libzapitu-rf/worker'
+ *   const sock = makeWASocket({ ... })
+ *   sock.ev.on('messages.upsert', ...)
+ *   await sock.sendMessage(...)
+ *
+ *   // Pool stats (available on every socket):
+ *   console.log(sock.pool) // { size, active, idle, totalSockets }
+ *
+ *   // Global pool control:
+ *   import { resizePool, drainPool, getStats } from 'libzapitu-rf/worker'
+ *   await resizePool(4)   // scale to 4 workers
+ *   await drainPool()     // wait for all sockets to close, then terminate
+ */
+import makeWASocket, { getStats, resizePool, drainPool } from './proxy';
+export * from '../Types';
+export * from '../Utils';
+export * from '../Defaults';
+export * from '../WABinary';
+export * from '../WAM';
+export * from '../WAUSync';
+export type WASocket = ReturnType<typeof makeWASocket>;
+export { makeWASocket, getStats, resizePool, drainPool };
+export default makeWASocket;

package/lib/worker/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drainPool = exports.resizePool = exports.getStats = exports.makeWASocket = void 0;
+/**
+ * Worker entry point — encapsulated mode.
+ *
+ * Import from here to run makeWASocket inside a child worker_threads
+ * process instead of the main thread.  Multiple sockets are automatically
+ * distributed across a pool of workers (default: CPU count).
+ *
+ * @example
+ *   import makeWASocket from 'libzapitu-rf/worker'
+ *   const sock = makeWASocket({ ... })
+ *   sock.ev.on('messages.upsert', ...)
+ *   await sock.sendMessage(...)
+ *
+ *   // Pool stats (available on every socket):
+ *   console.log(sock.pool) // { size, active, idle, totalSockets }
+ *
+ *   // Global pool control:
+ *   import { resizePool, drainPool, getStats } from 'libzapitu-rf/worker'
+ *   await resizePool(4)   // scale to 4 workers
+ *   await drainPool()     // wait for all sockets to close, then terminate
+ */
+const proxy_1 = __importStar(require("./proxy"));
+exports.makeWASocket = proxy_1.default;
+Object.defineProperty(exports, "getStats", { enumerable: true, get: function () { return proxy_1.getStats; } });
+Object.defineProperty(exports, "resizePool", { enumerable: true, get: function () { return proxy_1.resizePool; } });
+Object.defineProperty(exports, "drainPool", { enumerable: true, get: function () { return proxy_1.drainPool; } });
+__exportStar(require("../Types"), exports);
+__exportStar(require("../Utils"), exports);
+__exportStar(require("../Defaults"), exports);
+__exportStar(require("../WABinary"), exports);
+__exportStar(require("../WAM"), exports);
+__exportStar(require("../WAUSync"), exports);
+exports.default = proxy_1.default;

package/lib/worker/proxy.d.ts

@@ -0,0 +1,24 @@
+import type { UserFacingSocketConfig } from '../Types';
+interface PoolStats {
+    /** Total workers in the pool */
+    size: number;
+    /** Workers currently handling at least one socket */
+    active: number;
+    /** Workers with zero sockets */
+    idle: number;
+    /** Total sockets across all workers */
+    totalSockets: number;
+}
+declare function getStats(): PoolStats;
+/**
+ * Resize the pool. If shrinking, idle workers are terminated first.
+ * Active workers are never forcefully killed by resize.
+ */
+declare function resizePool(newSize: number): Promise<void>;
+/**
+ * Drain the pool: wait until all sockets are closed, then terminate all workers.
+ */
+declare function drainPool(): Promise<void>;
+declare const makeWASocket: (config: UserFacingSocketConfig) => any;
+export default makeWASocket;
+export { makeWASocket, getStats, resizePool, drainPool };

package/lib/worker/proxy.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWASocket = void 0;
+exports.getStats = getStats;
+exports.resizePool = resizePool;
+exports.drainPool = drainPool;
+/**
+ * Worker proxy — parent-side pool manager.
+ *
+ * Maintains a pool of worker_threads children, each running a real
+ * makeWASocket.  The pool automatically distributes new socket requests
+ * across workers and provides lifecycle control.
+ *
+ * Usage (encapsulated mode):
+ *   import makeWASocket from 'libzapitu-rf/worker'
+ *   const sock = makeWASocket({ ... })
+ *   sock.ev.on('messages.upsert', ...)
+ *   await sock.sendMessage(...)
+ *
+ * Pool control (available on the returned socket):
+ *   sock.pool — { size, active, idle, totalSockets }
+ *
+ * Global pool control:
+ *   import { resizePool, drainPool, getStats } from 'libzapitu-rf/worker'
+ */
+const worker_threads_1 = require("worker_threads");
+const events_1 = require("events");
+const os_1 = require("os");
+const path_1 = require("path");
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+const CALLBACK_CONFIG_KEYS = [
+    'getMessage',
+    'shouldIgnoreJid',
+    'patchMessageBeforeSending',
+    'cachedGroupMetadata',
+    'shouldSyncHistoryMessage',
+    'makeSignalRepository',
+];
+// ---------------------------------------------------------------------------
+// Globals
+// ---------------------------------------------------------------------------
+let _reqId = 0;
+const nextReqId = () => ++_reqId;
+let _socketId = 0;
+const nextSocketId = () => ++_socketId;
+const workerScript = (0, path_1.join)(__dirname, 'child.js');
+/** Active worker slots */
+const slots = [];
+/** Maximum workers allowed (default: CPU count) */
+let maxWorkers = (0, os_1.cpus)().length;
+// ---------------------------------------------------------------------------
+// Pool management
+// ---------------------------------------------------------------------------
+function getStats() {
+    const active = slots.filter(s => s.load > 0).length;
+    return {
+        size: slots.length,
+        active,
+        idle: slots.length - active,
+        totalSockets: slots.reduce((sum, s) => sum + s.load, 0),
+    };
+}
+/**
+ * Find the best worker to place a new socket on.
+ * Strategy: pick the worker with the lowest load; if all are at capacity
+ * and we haven't hit maxWorkers, spawn a new one.
+ */
+function acquireSlot() {
+    // Find least-loaded existing worker
+    let best = slots[0];
+    for (let i = 1; i < slots.length; i++) {
+        if (slots[i].load < best.load) {
+            best = slots[i];
+        }
+    }
+    // If the best worker already has sockets and we can grow, spawn a new one
+    if (best && best.load > 0 && slots.length < maxWorkers) {
+        return spawnWorker();
+    }
+    if (!best) {
+        return spawnWorker();
+    }
+    return best;
+}
+function spawnWorker() {
+    const worker = new worker_threads_1.Worker(workerScript);
+    const slot = {
+        worker,
+        load: 0,
+        emitters: new Map(),
+        callbacks: new Map(),
+        pending: new Map(),
+    };
+    // Global message handler — dispatches to the right socket's emitter
+    worker.on('message', (msg) => {
+        if (!msg || typeof msg !== 'object')
+            return;
+        const socketId = msg.socketId;
+        switch (msg.type) {
+            case 'event':
+                if (socketId !== undefined) {
+                    const ev = slot.emitters.get(socketId);
+                    if (ev)
+                        ev.emit(msg.event, msg.data);
+                }
+                break;
+            case 'result': {
+                const p = slot.pending.get(msg.id);
+                if (p) {
+                    slot.pending.delete(msg.id);
+                    if (msg.error) {
+                        p.reject(new Error(msg.error));
+                    }
+                    else {
+                        p.resolve(msg.result);
+                    }
+                }
+                break;
+            }
+            case 'callback-call':
+                if (socketId !== undefined) {
+                    handleCallbackCall(slot, socketId, msg);
+                }
+                break;
+        }
+    });
+    worker.on('error', () => {
+        const idx = slots.indexOf(slot);
+        if (idx !== -1)
+            slots.splice(idx, 1);
+    });
+    worker.on('exit', () => {
+        const idx = slots.indexOf(slot);
+        if (idx !== -1)
+            slots.splice(idx, 1);
+    });
+    slots.push(slot);
+    return slot;
+}
+async function handleCallbackCall(slot, socketId, msg) {
+    const { id, key, args } = msg;
+    const store = slot.callbacks.get(socketId);
+    const fn = store === null || store === void 0 ? void 0 : store[key];
+    if (!fn) {
+        return slot.worker.postMessage({
+            type: 'callback-result',
+            socketId,
+            id,
+            error: `No callback registered for "${key}"`,
+        });
+    }
+    try {
+        const result = await fn(...args);
+        slot.worker.postMessage({ type: 'callback-result', socketId, id, result });
+    }
+    catch (err) {
+        slot.worker.postMessage({
+            type: 'callback-result',
+            socketId,
+            id,
+            error: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+        });
+    }
+}
+/**
+ * Resize the pool. If shrinking, idle workers are terminated first.
+ * Active workers are never forcefully killed by resize.
+ */
+async function resizePool(newSize) {
+    if (newSize < 1)
+        newSize = 1;
+    maxWorkers = newSize;
+    // Terminate excess idle workers
+    while (slots.length > maxWorkers) {
+        const idleSlot = slots.find(s => s.load === 0);
+        if (!idleSlot)
+            break; // all busy, can't shrink further
+        const idx = slots.indexOf(idleSlot);
+        slots.splice(idx, 1);
+        await idleSlot.worker.terminate();
+    }
+}
+/**
+ * Drain the pool: wait until all sockets are closed, then terminate all workers.
+ */
+async function drainPool() {
+    // Wait for all sockets to close (load drops to 0)
+    await new Promise(resolve => {
+        const check = () => {
+            if (slots.every(s => s.load === 0)) {
+                resolve();
+            }
+            else {
+                setTimeout(check, 100);
+            }
+        };
+        check();
+    });
+    // Terminate all workers
+    await Promise.all(slots.map(s => s.worker.terminate()));
+    slots.length = 0;
+}
+// ---------------------------------------------------------------------------
+// makeWASocket (pool-aware proxy)
+// ---------------------------------------------------------------------------
+const makeWASocket = (config) => {
+    const socketId = nextSocketId();
+    // ---- Extract non-serializable callbacks ------------------------------
+    const callbackStore = {};
+    const serializableConfig = { ...config };
+    for (const k of CALLBACK_CONFIG_KEYS) {
+        if (typeof serializableConfig[k] === 'function') {
+            callbackStore[k] = serializableConfig[k];
+            serializableConfig[k] = '__proxy_callback__';
+        }
+    }
+    // ---- Acquire a worker slot -------------------------------------------
+    const slot = acquireSlot();
+    slot.load++;
+    slot.emitters.set(socketId, new events_1.EventEmitter());
+    slot.callbacks.set(socketId, callbackStore);
+    // ---- Send init message to the worker for this socket -----------------
+    slot.worker.postMessage({
+        type: 'init',
+        socketId,
+        config: serializableConfig,
+    });
+    // ---- Public event emitter (local to this socket) ---------------------
+    const ev = slot.emitters.get(socketId);
+    // ---- RPC helper ------------------------------------------------------
+    const rpcCall = (method, args) => {
+        const id = nextReqId();
+        return new Promise((resolve, reject) => {
+            slot.pending.set(id, { resolve, reject });
+            slot.worker.postMessage({ type: 'call', socketId, id, method, args });
+        });
+    };
+    // ---- Build the proxy object ------------------------------------------
+    const socketProxy = new Proxy({ ev }, {
+        get(_target, prop) {
+            if (prop === 'ev')
+                return ev;
+            if (prop === 'then')
+                return undefined;
+            if (prop === 'pool')
+                return getStats();
+            if (prop === 'end') {
+                return async (...args) => {
+                    try {
+                        await rpcCall('end', args);
+                    }
+                    catch (_) { /* ok */ }
+                    cleanupSocket(slot, socketId);
+                };
+            }
+            if (prop === 'logout') {
+                return async (...args) => {
+                    try {
+                        await rpcCall('logout', args);
+                    }
+                    catch (_) { /* ok */ }
+                    cleanupSocket(slot, socketId);
+                };
+            }
+            return (...args) => rpcCall(prop, args);
+        },
+    });
+    return socketProxy;
+};
+exports.makeWASocket = makeWASocket;
+function cleanupSocket(slot, socketId) {
+    slot.emitters.delete(socketId);
+    slot.callbacks.delete(socketId);
+    slot.load = Math.max(0, slot.load - 1);
+    // If the worker is now idle and we're over capacity, terminate it
+    if (slot.load === 0 && slots.length > maxWorkers) {
+        const idx = slots.indexOf(slot);
+        if (idx !== -1) {
+            slots.splice(idx, 1);
+            slot.worker.terminate();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+exports.default = makeWASocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libzapitu",
-  "version": "1.0.0-alpha.16",
+  "version": "1.0.0-alpha.18",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -14,8 +14,26 @@
   "author": "Zapitu Project",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./worker": {
+      "types": "./lib/worker/index.d.ts",
+      "default": "./lib/worker/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "worker": [
+        "./lib/worker/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "lib/*",
+    "lib/worker/*",
     "WAProto/*",
     "engine-requirements.js"
   ],