libzapitu 1.0.0-alpha.24 → 1.0.0-alpha.26

package/lib/worker/child.js

@@ -76,22 +76,79 @@ function proxyCallback(socketId, key, log, ...args) {
 // Create a socket for a given socketId
 // ---------------------------------------------------------------------------
 /**
- * Recursively clone a value, replacing non-cloneable types (Error, Function)
- * with plain serializable representations.
+ * Recursively clone a value for postMessage, replacing non-cloneable types
+ * (Error, Function) with plain serializable representations, preserving
+ * built-in value objects, and converting protobufjs message instances to JSON.
+ *
+ * Protobuf messages (e.g. proto.Message, proto.WebMessageInfo) carry a
+ * toJSON() method that serializes byte fields as base64 strings and 64-bit
+ * integer fields as strings. Structured clone strips the prototype chain, so
+ * without this step Buffers become Uint8Array plain objects and Longs become
+ * { low, high, unsigned } objects on the parent side. Converting them before
+ * crossing the boundary keeps the worker event shape identical to direct mode
+ * when the data is logged or JSON.stringify'd.
  */
-function sanitizeForPostMessage(value, seen = new WeakSet()) {
+function serializeForPostMessage(value, seen = new WeakSet()) {
     if (value instanceof Error) {
+        // Boom carries critical metadata (statusCode, output, data, isServer).
+        // Preserve it so the parent can reconstruct a real Boom instance.
+        if (value.isBoom) {
+            return {
+                __error__: true,
+                __boom__: true,
+                message: value.message,
+                name: value.name,
+                stack: value.stack,
+                data: value.data,
+                output: value.output,
+                isServer: value.isServer
+            };
+        }
         return { __error__: true, message: value.message, name: value.name, stack: value.stack };
     }
     if (typeof value === 'function') {
         return '__fn__';
     }
+    // Preserve built-in value objects that structured clone handles, but tag
+    // them so the parent can reconstruct the exact same runtime type.
+    if (value instanceof Date) {
+        return { __date__: true, value: value.toISOString() };
+    }
+    if (value instanceof RegExp) {
+        return { __regexp__: true, source: value.source, flags: value.flags };
+    }
+    if (value instanceof URL) {
+        return { __url__: true, href: value.href };
+    }
+    if (value instanceof Map) {
+        return { __map__: true, entries: serializeForPostMessage(Array.from(value.entries()), seen) };
+    }
+    if (value instanceof Set) {
+        return { __set__: true, entries: serializeForPostMessage(Array.from(value.values()), seen) };
+    }
     if (value !== null && typeof value === 'object') {
         if (seen.has(value))
             return '[Circular]';
         seen.add(value);
+        // Detect a protobufjs message instance by the static methods its
+        // constructor exposes, then use the instance's own toJSON() so nested
+        // bytes/long fields are serialized consistently. Tag the resulting
+        // plain object with the constructor name so the parent can revive it
+        // back into a real protobuf instance (and therefore recover the
+        // runtime Buffer types downstream code expects).
+        const ctor = value.constructor;
+        if (ctor &&
+            typeof ctor === 'function' &&
+            typeof ctor.encode === 'function' &&
+            typeof ctor.decode === 'function' &&
+            typeof ctor.toObject === 'function' &&
+            typeof value.toJSON === 'function') {
+            const json = value.toJSON();
+            json.__protobufType__ = ctor.name;
+            return serializeForPostMessage(json, seen);
+        }
         if (Array.isArray(value)) {
-            return value.map(v => sanitizeForPostMessage(v, seen));
+            return value.map(v => serializeForPostMessage(v, seen));
         }
         // Preserve binary/typed-array types — structured clone handles them natively
         if (Buffer.isBuffer(value) ||
@@ -102,7 +159,7 @@ function sanitizeForPostMessage(value, seen = new WeakSet()) {
         }
         const result = {};
         for (const key of Object.keys(value)) {
-            result[key] = sanitizeForPostMessage(value[key], seen);
+            result[key] = serializeForPostMessage(value[key], seen);
         }
         return result;
     }
@@ -188,6 +245,8 @@ function createSocket(socketId, rawConfig) {
     log.info('socket created successfully');
     // Send user and authState to the parent when they become available.
     // These are needed for wsocket.user and wsocket.authState on the proxy side.
+    // authState.keys contains forwarding functions, so we must serialize the
+    // info before postMessage or the whole message is dropped.
     const sendSocketInfo = () => {
         try {
             const info = {};
@@ -196,7 +255,11 @@ function createSocket(socketId, rawConfig) {
             if (sock.authState)
                 info.authState = sock.authState;
             if (Object.keys(info).length > 0) {
-                worker_threads_1.parentPort.postMessage({ type: 'socket-info', socketId, info });
+                worker_threads_1.parentPort.postMessage({
+                    type: 'socket-info',
+                    socketId,
+                    info: serializeForPostMessage(info)
+                });
             }
         }
         catch (_) {
@@ -226,18 +289,10 @@ function createSocket(socketId, rawConfig) {
     sock.ev.on('event', (map) => {
         log.trace({ eventKeys: Object.keys(map) }, 'event → parent');
         try {
-            worker_threads_1.parentPort.postMessage({ type: 'event', socketId, map });
+            worker_threads_1.parentPort.postMessage({ type: 'event', socketId, map: serializeForPostMessage(map) });
         }
         catch (err) {
             log.error({ err, eventKeys: Object.keys(map) }, 'failed to send event to parent (non-cloneable data)');
-            // Attempt to send a sanitized version without Error objects
-            try {
-                const sanitized = sanitizeForPostMessage(map);
-                worker_threads_1.parentPort.postMessage({ type: 'event', socketId, map: sanitized });
-            }
-            catch (_) {
-                log.error({ eventKeys: Object.keys(map) }, 'event dropped — could not sanitize');
-            }
         }
     });
     // Forward raw WS events to the parent so ws.on() works on the proxy side.
@@ -305,11 +360,11 @@ worker_threads_1.parentPort.on('message', async (msg) => {
                     const thisCtx = path.length > 1 ? resolveTarget(sock, path.slice(0, -1)) : sock;
                     const result = await target.apply(thisCtx, args || []);
                     log.trace({ rpcId: id, method }, 'RPC call succeeded');
-                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result });
+                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result: serializeForPostMessage(result) });
                 }
                 else {
                     log.trace({ rpcId: id, method }, 'RPC property read');
-                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result: target });
+                    worker_threads_1.parentPort.postMessage({ type: 'result', socketId, id, result: serializeForPostMessage(target) });
                 }
             }
             catch (err) {

package/lib/worker/proxy.js

@@ -36,6 +36,8 @@ const stream_1 = require("stream");
 const util_1 = require("util");
 const os_2 = require("os");
 const long_1 = __importDefault(require("long"));
+const boom_1 = require("@hapi/boom");
+const WAProto_1 = require("../../WAProto");
 const pipelineAsync = (0, util_1.promisify)(stream_1.pipeline);
 // ---------------------------------------------------------------------------
 // Stream serialization for RPC boundary
@@ -224,23 +226,98 @@ function createNoopLogger() {
     };
 }
 /**
- * Recursively revive objects that were sanitized by the child's
- * sanitizeForPostMessage (e.g. Error sentinels) or decomposed by
- * structured clone (e.g. Long → { low, high, unsigned }).
+ * Build a lookup table from protobufjs type name to the generated
+ * constructor. This lets us revive a message that was serialized to JSON
+ * in the worker back into a real protobuf instance on the parent side.
+ */
+function buildProtobufTypeRegistry(namespace, result = new Map()) {
+    for (const [key, value] of Object.entries(namespace)) {
+        if (typeof value === 'function' && value.fromObject && value.encode && value.decode) {
+            result.set(value.name || key, value);
+        }
+        else if (value !== null && typeof value === 'object' && !value.fromObject) {
+            buildProtobufTypeRegistry(value, result);
+        }
+    }
+    return result;
+}
+const PROTOBUF_TYPE_REGISTRY = buildProtobufTypeRegistry(WAProto_1.proto);
+/**
+ * Recursively revive objects that were serialized by the child's
+ * serializeForPostMessage (e.g. Error sentinels, protobuf messages) or
+ * decomposed by structured clone (e.g. Long → { low, high, unsigned },
+ * Buffer → Uint8Array).
  *
- * IMPORTANT: structured clone already produces a perfect copy of the data.
- * We only need to recursively look for __error__ sentinels and convert
- * them back to Error instances, and revive Long-like plain objects back
- * to real Long instances. Everything else passes through unchanged.
+ * Protobuf message instances are converted to JSON by the child, tagged with
+ * __protobufType__, and then revived here with the corresponding
+ * constructor's fromObject(). This restores the runtime Buffer/Long types
+ * that downstream code expects while keeping JSON.stringify output identical
+ * to direct mode (base64 strings for bytes, strings for 64-bit integers).
  */
 function revivePostMessage(value) {
+    var _a;
+    // After structured clone, Buffer subclasses become plain Uint8Arrays.
+    // Restore them to Buffer so downstream code gets the same type as in
+    // direct mode for non-protobuf binary fields.
+    if (value instanceof Uint8Array && !Buffer.isBuffer(value)) {
+        return Buffer.from(value);
+    }
     if (value !== null && typeof value === 'object') {
         if (value.__error__) {
+            // Boom errors carry status codes, payloads, and extra data. Rebuild
+            // a real Boom instance so callers can inspect err.output.statusCode.
+            if (value.__boom__) {
+                const boom = new boom_1.Boom(value.message, {
+                    statusCode: (_a = value.output) === null || _a === void 0 ? void 0 : _a.statusCode,
+                    data: value.data
+                });
+                // Restore the exact output payload/headers from the worker so the
+                // status code and error name match direct mode.
+                if (value.output) {
+                    Object.assign(boom.output, value.output);
+                }
+                boom.stack = value.stack || boom.stack;
+                return boom;
+            }
             const err = new Error(value.message);
             err.name = value.name;
             err.stack = value.stack;
             return err;
         }
+        // Revive built-in value objects tagged by the child.
+        if (value.__date__) {
+            return new Date(value.value);
+        }
+        if (value.__regexp__) {
+            return new RegExp(value.source, value.flags);
+        }
+        if (value.__url__) {
+            return new URL(value.href);
+        }
+        if (value.__map__) {
+            return new Map(revivePostMessage(value.entries));
+        }
+        if (value.__set__) {
+            return new Set(revivePostMessage(value.entries));
+        }
+        // Revive protobuf messages tagged by the child. fromObject() will
+        // recursively recreate nested protobuf instances and convert base64
+        // strings back into Buffer instances.
+        const protobufType = value.__protobufType__;
+        if (protobufType) {
+            const type = PROTOBUF_TYPE_REGISTRY.get(protobufType);
+            if (type === null || type === void 0 ? void 0 : type.fromObject) {
+                const copy = { ...value };
+                delete copy.__protobufType__;
+                try {
+                    return type.fromObject(copy);
+                }
+                catch (_b) {
+                    // Fall back to the plain JSON object if fromObject fails;
+                    // downstream code will see base64 strings instead of Buffers.
+                }
+            }
+        }
         // Revive Long-like objects that were decomposed by structured clone.
         // protobufjs uses Long for 64-bit integers; after postMessage they
         // become { low, high, unsigned } plain objects.
@@ -248,7 +325,7 @@ function revivePostMessage(value) {
             return new long_1.default(value.low, value.high, value.unsigned);
         }
         if (Array.isArray(value)) {
-            // Arrays: recurse to revive any Error sentinels / Longs inside
+            // Arrays: recurse to revive any Error sentinels / Longs / Uint8Arrays / protobuf messages / built-ins inside
             let changed = false;
             const result = value.map(v => {
                 const revived = revivePostMessage(v);
@@ -258,8 +335,8 @@ function revivePostMessage(value) {
             });
             return changed ? result : value;
         }
-        // Plain objects: only recurse if they might contain __error__ sentinels
-        // or Long-like objects.
+        // Plain objects: only recurse if they might contain __error__ sentinels,
+        // Long-like objects, Uint8Arrays, protobuf markers, or built-in tags.
         if (value.constructor === Object || value.constructor === undefined) {
             let changed = false;
             const result = {};
@@ -471,7 +548,12 @@ async function handleCallbackCall(slot, socketId, msg) {
         try {
             log === null || log === void 0 ? void 0 : log.debug({ keystoreMethod: method, argCount: args.length }, 'invoking keystore method');
             const result = await keystore[method](...args);
-            slot.worker.postMessage({ type: 'callback-result', socketId, id, result });
+            slot.worker.postMessage({
+                type: 'callback-result',
+                socketId,
+                id,
+                result: deepStripFunctions(result)
+            });
         }
         catch (err) {
             log === null || log === void 0 ? void 0 : log.error({ err, keystoreMethod: method }, 'keystore method threw error');
@@ -499,7 +581,12 @@ async function handleCallbackCall(slot, socketId, msg) {
     try {
         log === null || log === void 0 ? void 0 : log.debug({ callbackKey: key, argCount: args.length }, 'invoking proxied callback');
         const result = await fn(...args);
-        slot.worker.postMessage({ type: 'callback-result', socketId, id, result });
+        slot.worker.postMessage({
+            type: 'callback-result',
+            socketId,
+            id,
+            result: deepStripFunctions(result)
+        });
     }
     catch (err) {
         log === null || log === void 0 ? void 0 : log.error({ err, callbackKey: key }, 'proxied callback threw error');
@@ -572,8 +659,30 @@ async function drainPool() {
  * Recursively clone a value, replacing all functions with the sentinel
  * string '__proxy_fn__'. This ensures the config can be sent via
  * postMessage (structured clone).
+ *
+ * Built-in value objects (Date, RegExp, URL, Map, Set) are preserved in
+ * their serializable tagged form so they survive the boundary instead of
+ * being reduced to empty objects by Object.keys().
  */
 function deepStripFunctions(value, seen = new WeakSet()) {
+    if (typeof value === 'function') {
+        return '__proxy_fn__';
+    }
+    if (value instanceof Date) {
+        return { __date__: true, value: value.toISOString() };
+    }
+    if (value instanceof RegExp) {
+        return { __regexp__: true, source: value.source, flags: value.flags };
+    }
+    if (value instanceof URL) {
+        return { __url__: true, href: value.href };
+    }
+    if (value instanceof Map) {
+        return { __map__: true, entries: deepStripFunctions(Array.from(value.entries()), seen) };
+    }
+    if (value instanceof Set) {
+        return { __set__: true, entries: deepStripFunctions(Array.from(value.values()), seen) };
+    }
     if (typeof value === 'function') {
         return '__proxy_fn__';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libzapitu",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.26",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",