libzapitu 1.0.0-alpha.22 → 1.0.0-alpha.24

package/lib/Socket/chats.js

@@ -467,20 +467,30 @@ const makeChatsSocket = (config) => {
      * type = "image for the high res picture"
      */
     const profilePictureUrl = async (jid, type = 'preview', timeoutMs) => {
-        var _a;
+        var _a, _b;
         jid = (0, WABinary_1.jidNormalizedUser)(jid);
-        const result = await query({
-            tag: 'iq',
-            attrs: {
-                target: jid,
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'w:profile:picture'
-            },
-            content: [{ tag: 'picture', attrs: { type, query: 'url' } }]
-        }, timeoutMs);
-        const child = (0, WABinary_1.getBinaryNodeChild)(result, 'picture');
-        return (_a = child === null || child === void 0 ? void 0 : child.attrs) === null || _a === void 0 ? void 0 : _a.url;
+        try {
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    target: jid,
+                    to: WABinary_1.S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'w:profile:picture'
+                },
+                content: [{ tag: 'picture', attrs: { type, query: 'url' } }]
+            }, timeoutMs);
+            const child = (0, WABinary_1.getBinaryNodeChild)(result, 'picture');
+            return (_a = child === null || child === void 0 ? void 0 : child.attrs) === null || _a === void 0 ? void 0 : _a.url;
+        }
+        catch (err) {
+            // WhatsApp returns 404/"item-not-found" when the contact has no profile picture.
+            // This is a normal situation — return undefined instead of throwing.
+            if ((err === null || err === void 0 ? void 0 : err.data) === 404 || ((_b = err === null || err === void 0 ? void 0 : err.message) === null || _b === void 0 ? void 0 : _b.includes('item-not-found'))) {
+                return undefined;
+            }
+            throw err;
+        }
     };
     const sendPresenceUpdate = async (type, toJid) => {
         const me = authState.creds.me;

package/lib/worker/proxy.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeWASocket = void 0;
 exports.getStats = getStats;
@@ -27,7 +30,143 @@ const worker_threads_1 = require("worker_threads");
 const events_1 = require("events");
 const os_1 = require("os");
 const fs_1 = require("fs");
+const fs_2 = require("fs");
 const path_1 = require("path");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const os_2 = require("os");
+const long_1 = __importDefault(require("long"));
+const pipelineAsync = (0, util_1.promisify)(stream_1.pipeline);
+// ---------------------------------------------------------------------------
+// Stream serialization for RPC boundary
+// ---------------------------------------------------------------------------
+/** Maximum bytes to buffer in memory before falling back to a temp file. */
+const STREAM_BUFFER_MAX_BYTES = 50 * 1024 * 1024; // 50 MB
+/**
+ * Read a Readable stream into a Buffer, enforcing a maximum size.
+ * If the stream exceeds `maxBytes`, it is destroyed and an error is thrown.
+ */
+async function streamToBuffer(stream, maxBytes) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of stream) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buf.length;
+        if (totalBytes > maxBytes) {
+            stream.destroy();
+            throw new Error(`Stream exceeds maximum buffer size of ${maxBytes} bytes`);
+        }
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks);
+}
+/**
+ * Write a Readable stream to a temporary file.
+ * Returns the absolute path to the temp file.
+ */
+async function streamToTempFile(stream) {
+    const tmpPath = (0, path_1.join)((0, os_2.tmpdir)(), `zapitu-proxy-upload-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const writeStream = (0, fs_2.createWriteStream)(tmpPath);
+    try {
+        await pipelineAsync(stream, writeStream);
+        return tmpPath;
+    }
+    catch (err) {
+        // Clean up partial file on error
+        try {
+            await fs_1.promises.unlink(tmpPath);
+        }
+        catch (_a) {
+            /* best-effort */
+        }
+        throw err;
+    }
+}
+/**
+ * Attempt to determine the byte size of a stream from its known properties.
+ * Returns `undefined` if the size cannot be determined without consuming.
+ */
+function tryGetStreamSize(stream) {
+    // fs.ReadStream exposes bytesRead + a path we could stat, but bytesRead
+    // is only populated after reading. Check for content-length on HTTP-like
+    // streams (e.g. axios responses).
+    const headers = stream === null || stream === void 0 ? void 0 : stream.headers;
+    if (headers === null || headers === void 0 ? void 0 : headers['content-length']) {
+        const len = parseInt(headers['content-length'], 10);
+        if (!isNaN(len))
+            return len;
+    }
+    // readableLength is a Node.js internal that gives buffered bytes, not total.
+    // Not useful here.
+    return undefined;
+}
+/**
+ * Convert a Readable stream into a postMessage-safe representation.
+ *
+ * Strategy:
+ * 1. If the stream size is known and ≤ 50 MB → buffer in memory.
+ * 2. If the stream size is known and > 50 MB → write to temp file.
+ * 3. If the stream size is unknown → write to temp file (safe default).
+ *
+ * The caller is responsible for cleaning up temp files after the RPC call
+ * completes (success or failure).
+ */
+async function serializeStream(stream) {
+    const knownSize = tryGetStreamSize(stream);
+    if (knownSize !== undefined && knownSize <= STREAM_BUFFER_MAX_BYTES) {
+        const buffer = await streamToBuffer(stream, STREAM_BUFFER_MAX_BYTES);
+        return { buffer };
+    }
+    // Unknown size or known to be large → temp file
+    const tempFilePath = await streamToTempFile(stream);
+    return { tempFilePath };
+}
+/**
+ * Recursively walk an argument tree and convert any `{ stream: Readable }`
+ * objects into postMessage-safe representations.
+ *
+ * After this function, the args are safe to pass to `worker.postMessage()`.
+ * Returns a cleanup function that should be called after the RPC completes
+ * to remove any temp files that were created.
+ */
+async function serializeStreamArgs(args) {
+    const tempFiles = [];
+    const walk = async (value) => {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value !== 'object')
+            return value;
+        // Detect { stream: Readable } — the WAMediaPayloadStream shape
+        if ('stream' in value && value.stream instanceof stream_1.Readable) {
+            const stream = value.stream;
+            const result = await serializeStream(stream);
+            if ('tempFilePath' in result) {
+                tempFiles.push(result.tempFilePath);
+                // Replace with { url: filePath } so the worker's getStream()
+                // treats it as a local file path (WAMediaPayloadURL shape).
+                return { url: result.tempFilePath };
+            }
+            // Buffer — pass directly; the worker's getStream() handles Buffer natively
+            return result.buffer;
+        }
+        if (Array.isArray(value)) {
+            return Promise.all(value.map(v => walk(v)));
+        }
+        if (Buffer.isBuffer(value) || value instanceof Uint8Array || value instanceof ArrayBuffer) {
+            return value;
+        }
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = await walk(val);
+        }
+        return result;
+    };
+    const processed = await Promise.all(args.map(a => walk(a)));
+    const cleanup = async () => {
+        await Promise.allSettled(tempFiles.map(p => fs_1.promises.unlink(p).catch(() => { })));
+    };
+    return { processed, cleanup };
+}
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -86,11 +225,13 @@ function createNoopLogger() {
 }
 /**
  * Recursively revive objects that were sanitized by the child's
- * sanitizeForPostMessage (e.g. Error sentinels).
+ * sanitizeForPostMessage (e.g. Error sentinels) or decomposed by
+ * structured clone (e.g. Long → { low, high, unsigned }).
  *
  * 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. Everything else passes through unchanged.
+ * them back to Error instances, and revive Long-like plain objects back
+ * to real Long instances. Everything else passes through unchanged.
  */
 function revivePostMessage(value) {
     if (value !== null && typeof value === 'object') {
@@ -100,19 +241,25 @@ function revivePostMessage(value) {
             err.stack = value.stack;
             return err;
         }
+        // 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.
+        if (isLongLike(value)) {
+            return new long_1.default(value.low, value.high, value.unsigned);
+        }
         if (Array.isArray(value)) {
-            // Arrays: recurse to revive any Error sentinels inside
-            let hasError = false;
+            // Arrays: recurse to revive any Error sentinels / Longs inside
+            let changed = false;
             const result = value.map(v => {
                 const revived = revivePostMessage(v);
                 if (revived !== v)
-                    hasError = true;
+                    changed = true;
                 return revived;
             });
-            return hasError ? result : value;
+            return changed ? result : value;
         }
-        // Plain objects: only recurse if they might contain __error__ sentinels.
-        // Check one level deep to avoid unnecessary cloning of large objects.
+        // Plain objects: only recurse if they might contain __error__ sentinels
+        // or Long-like objects.
         if (value.constructor === Object || value.constructor === undefined) {
             let changed = false;
             const result = {};
@@ -128,6 +275,23 @@ function revivePostMessage(value) {
     }
     return value;
 }
+/**
+ * Check whether a value looks like a protobufjs Long that was decomposed
+ * by structured clone. Long instances have exactly { low, high, unsigned }
+ * after crossing postMessage.
+ */
+function isLongLike(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const keys = Object.keys(value);
+    return (keys.length === 3 &&
+        keys.includes('low') &&
+        keys.includes('high') &&
+        keys.includes('unsigned') &&
+        typeof value.low === 'number' &&
+        typeof value.high === 'number' &&
+        typeof value.unsigned === 'boolean');
+}
 // ---------------------------------------------------------------------------
 // Pool management
 // ---------------------------------------------------------------------------
@@ -255,7 +419,7 @@ function spawnWorker() {
                     }
                     else {
                         log === null || log === void 0 ? void 0 : log.trace({ rpcId: msg.id }, 'worker RPC result');
-                        p.resolve(msg.result);
+                        p.resolve(revivePostMessage(msg.result));
                     }
                 }
                 break;
@@ -635,6 +799,17 @@ const makeWASocket = (config) => {
                     cleanupSocket(slot, socketId, log);
                 };
             }
+            if (prop === 'sendMessage') {
+                return async (...args) => {
+                    const { processed, cleanup } = await serializeStreamArgs(args);
+                    try {
+                        return await rpcCall('sendMessage', processed);
+                    }
+                    finally {
+                        await cleanup();
+                    }
+                };
+            }
             return (...args) => rpcCall(prop, args);
         },
         set(_target, prop, value) {

package/package.json

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