zapo-js 1.8.2 → 1.9.0

package/dist/auth/credentials-flow.js

@@ -113,9 +113,7 @@ async function buildCommsConfig(logger, credentials, socketOptions, clientOption
         assertValidVersion(resolvedVersion, Boolean(effectiveMobileTransport));
     }
     if (effectiveMobileTransport) {
-        if (wsProxy) {
-            throw new Error('mobileTransport does not support socketOptions.proxy.ws – remove the proxy option or open an issue to add TCP proxy support');
-        }
+        (0, proxy_1.assertTcpProxySupported)(wsProxy);
         if (!loginIdentity) {
             throw new Error('mobileTransport requires registered credentials (meJid) – run the mobile bridge flow first');
         }
@@ -138,6 +136,7 @@ async function buildCommsConfig(logger, credentials, socketOptions, clientOption
         return {
             url: effectiveMobileTransport.tcpUrl ?? 'tcp://g.whatsapp.net:443',
             rawWebSocketConstructor: WaMobileTcpSocket_1.WaMobileTcpSocketCtor,
+            agent: (0, proxy_1.toProxyAgent)(wsProxy),
             connectTimeoutMs: socketOptions.connectTimeoutMs,
             reconnectIntervalMs: socketOptions.reconnectIntervalMs,
             timeoutIntervalMs: socketOptions.timeoutIntervalMs,

package/dist/esm/auth/credentials-flow.js

@@ -5,7 +5,7 @@ import { getLoginIdentity } from '../protocol/jid.js';
 import { createAndStoreInitialKeys } from '../signal/index.js';
 import { WaMobileTcpSocketCtor } from '../transport/node/WaMobileTcpSocket.js';
 import { buildMobileLoginPayload } from '../transport/noise/WaMobileClientPayload.js';
-import { toProxyAgent, toProxyDispatcher } from '../transport/proxy.js';
+import { assertTcpProxySupported, toProxyAgent, toProxyDispatcher } from '../transport/proxy.js';
 import { parseOptionalInt, toError } from '../util/primitives.js';
 export async function loadOrCreateCredentials(args) {
     args.logger.trace('auth credentials loadOrCreate start');
@@ -108,9 +108,7 @@ export async function buildCommsConfig(logger, credentials, socketOptions, clien
         assertValidVersion(resolvedVersion, Boolean(effectiveMobileTransport));
     }
     if (effectiveMobileTransport) {
-        if (wsProxy) {
-            throw new Error('mobileTransport does not support socketOptions.proxy.ws – remove the proxy option or open an issue to add TCP proxy support');
-        }
+        assertTcpProxySupported(wsProxy);
         if (!loginIdentity) {
             throw new Error('mobileTransport requires registered credentials (meJid) – run the mobile bridge flow first');
         }
@@ -133,6 +131,7 @@ export async function buildCommsConfig(logger, credentials, socketOptions, clien
         return {
             url: effectiveMobileTransport.tcpUrl ?? 'tcp://g.whatsapp.net:443',
             rawWebSocketConstructor: WaMobileTcpSocketCtor,
+            agent: toProxyAgent(wsProxy),
             connectTimeoutMs: socketOptions.connectTimeoutMs,
             reconnectIntervalMs: socketOptions.reconnectIntervalMs,
             timeoutIntervalMs: socketOptions.timeoutIntervalMs,

package/dist/esm/message/encode/content.js

@@ -154,7 +154,8 @@ export function unwrapMessage(message) {
             msg.viewOnceMessageV2?.message ??
             msg.documentWithCaptionMessage?.message ??
             msg.groupStatusMessage?.message ??
-            msg.groupStatusMessageV2?.message;
+            msg.groupStatusMessageV2?.message ??
+            msg.botForwardedMessage?.message;
         if (!inner)
             return msg;
         msg = inner;
@@ -202,6 +203,8 @@ function resolveMessageTypeAttrFrom(msg) {
         msg.pollResultSnapshotMessageV3 ||
         msg.templateButtonReplyMessage ||
         msg.messageHistoryNotice ||
+        msg.richResponseMessage ||
+        msg.botForwardedMessage ||
         msg.secretEncryptedMessage?.secretEncType ===
             proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
         msg.secretEncryptedMessage?.secretEncType ===

package/dist/esm/transport/node/WaMobileTcpSocket.js

@@ -1,13 +1,14 @@
 import { connect as netConnect } from 'node:net';
 import { WA_READY_STATES } from '../../protocol/constants.js';
-import { TEXT_ENCODER } from '../../util/bytes.js';
+import { toTcpProxyEndpoint } from '../proxy.js';
+import { concatBytes, TEXT_DECODER, TEXT_ENCODER } from '../../util/bytes.js';
 /**
  * `RawWebSocket`-shaped adapter over a raw Node TCP socket. Used by the
  * mobile transport to speak the WhatsApp Mobile binary protocol over
  * `tcp://host:port` URLs.
  */
 export class WaMobileTcpSocket {
-    constructor(url, _protocols, _options) {
+    constructor(url, _protocols, options) {
         this.binaryType = 'arraybuffer';
         this.readyState = WA_READY_STATES.CONNECTING;
         this.onopen = null;
@@ -19,19 +20,55 @@ export class WaMobileTcpSocket {
         this.closedClean = true;
         this.forceCloseTimer = null;
         const { host, port } = parseTcpUrl(url);
-        this.socket = netConnect({ host, port });
+        const proxy = toTcpProxyEndpoint(options?.agent);
+        this.socket = proxy
+            ? netConnect({ host: proxy.hostname, port: proxy.port })
+            : netConnect({ host, port });
+        let tunnelReady = !proxy;
+        let proxyResponse = new Uint8Array(0);
         this.socket.on('connect', () => {
             if (this.readyState !== WA_READY_STATES.CONNECTING)
                 return;
-            this.readyState = WA_READY_STATES.OPEN;
-            this.onopen?.({});
+            if (proxy) {
+                const authority = `${host}:${port}`;
+                const lines = [
+                    `CONNECT ${authority} HTTP/1.1`,
+                    `Host: ${authority}`,
+                    'Proxy-Connection: Keep-Alive'
+                ];
+                if (proxy.authorization)
+                    lines.push(`Proxy-Authorization: ${proxy.authorization}`);
+                this.socket.write(TEXT_ENCODER.encode(`${lines.join('\r\n')}\r\n\r\n`));
+                return;
+            }
+            this.markOpen();
         });
         this.socket.on('data', (chunk) => {
-            if (!this.onmessage || this.readyState !== WA_READY_STATES.OPEN)
+            if (!tunnelReady && proxy) {
+                proxyResponse = concatBytes([proxyResponse, chunk]);
+                const headerEnd = findHttpHeaderEnd(proxyResponse);
+                const scanned = headerEnd === -1 ? proxyResponse.byteLength : headerEnd;
+                if (scanned > MAX_PROXY_HEADER_BYTES) {
+                    this.socket.destroy(new Error('WaMobileTcpSocket: proxy response headers too large'));
+                    return;
+                }
+                if (headerEnd === -1) {
+                    return;
+                }
+                const statusLine = TEXT_DECODER.decode(proxyResponse.subarray(0, headerEnd)).split('\r\n')[0];
+                if (!/^HTTP\/1\.[01] 2\d\d(?:\s|$)/.test(statusLine)) {
+                    this.socket.destroy(new Error(`WaMobileTcpSocket: proxy CONNECT failed (${statusLine})`));
+                    return;
+                }
+                const remaining = proxyResponse.subarray(headerEnd + 4);
+                proxyResponse = new Uint8Array(0);
+                tunnelReady = true;
+                this.markOpen();
+                if (remaining.byteLength > 0)
+                    this.emitMessage(remaining);
                 return;
-            const copy = new Uint8Array(chunk.byteLength);
-            copy.set(chunk);
-            this.onmessage({ data: copy });
+            }
+            this.emitMessage(chunk);
         });
         this.socket.on('error', (err) => {
             this.closedClean = false;
@@ -53,6 +90,19 @@ export class WaMobileTcpSocket {
             });
         });
     }
+    markOpen() {
+        if (this.readyState !== WA_READY_STATES.CONNECTING)
+            return;
+        this.readyState = WA_READY_STATES.OPEN;
+        this.onopen?.({});
+    }
+    emitMessage(chunk) {
+        if (!this.onmessage || this.readyState !== WA_READY_STATES.OPEN)
+            return;
+        const copy = new Uint8Array(chunk.byteLength);
+        copy.set(chunk);
+        this.onmessage({ data: copy });
+    }
     send(data) {
         if (this.readyState !== WA_READY_STATES.OPEN) {
             throw new Error('WaMobileTcpSocket: send() called on non-OPEN socket');
@@ -85,6 +135,16 @@ export class WaMobileTcpSocket {
         this.forceCloseTimer.unref();
     }
 }
+/** Cap on the CONNECT response headers buffered before the tunnel is rejected. */
+const MAX_PROXY_HEADER_BYTES = 65536;
+function findHttpHeaderEnd(bytes) {
+    for (let i = 3; i < bytes.byteLength; i += 1) {
+        if (bytes[i - 3] === 13 && bytes[i - 2] === 10 && bytes[i - 1] === 13 && bytes[i] === 10) {
+            return i - 3;
+        }
+    }
+    return -1;
+}
 function parseTcpUrl(url) {
     let work = url;
     if (work.startsWith('tcp://')) {

package/dist/esm/transport/noise/WaMobileClientPayload.js

@@ -13,6 +13,20 @@ function parseAppVersion(version) {
         quaternary: at(3)
     };
 }
+function distributionChannelId(channel) {
+    const { DistributionChannel } = proto.ClientPayload.UserAgent;
+    switch (channel) {
+        case 'website':
+            return DistributionChannel.WEBSITE;
+        case 'testflight':
+            return DistributionChannel.TESTFLIGHT;
+        case 'internal':
+            return DistributionChannel.INTERNAL;
+        case 'appstore':
+        case undefined:
+            return DistributionChannel.APPSTORE;
+    }
+}
 /**
  * Builds the encoded {@link Proto.ClientPayload} bytes the WhatsApp Mobile
  * transport sends after the noise login handshake. Throws when
@@ -24,14 +38,18 @@ export function buildMobileLoginPayload(config) {
     }
     const info = config.deviceInfo;
     const version = parseAppVersion(info.appVersion);
-    const userAgent = {
-        platform: info.business
+    const isIos = info.os === 'ios';
+    const platform = isIos
+        ? info.business
+            ? proto.ClientPayload.UserAgent.Platform.SMB_IOS
+            : proto.ClientPayload.UserAgent.Platform.IOS
+        : info.business
             ? proto.ClientPayload.UserAgent.Platform.SMB_ANDROID
-            : proto.ClientPayload.UserAgent.Platform.ANDROID,
+            : proto.ClientPayload.UserAgent.Platform.ANDROID;
+    const userAgent = {
+        platform,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         appVersion: version,
-        mcc: info.mcc ?? '000',
-        mnc: info.mnc ?? '000',
         osVersion: info.osVersion,
         manufacturer: info.manufacturer,
         device: info.device,
@@ -40,8 +58,10 @@ export function buildMobileLoginPayload(config) {
         localeLanguageIso6391: info.localeLanguageIso6391 ?? 'en',
         localeCountryIso31661Alpha2: info.localeCountryIso31661Alpha2 ?? 'US',
         deviceType: proto.ClientPayload.UserAgent.DeviceType.PHONE,
-        deviceBoard: info.deviceBoard,
-        deviceModelType: info.deviceModelType
+        deviceModelType: info.deviceModelType,
+        ...(isIos
+            ? { distributionChannel: distributionChannelId(info.distributionChannel) }
+            : { mcc: info.mcc ?? '000', mnc: info.mnc ?? '000', deviceBoard: info.deviceBoard })
     };
     return proto.ClientPayload.encode({
         passive: config.passive === true,

package/dist/esm/transport/proxy.js

@@ -1,3 +1,4 @@
+import { bytesToBase64, TEXT_ENCODER } from '../util/bytes.js';
 /** Type guard for an undici-style proxy dispatcher (has `dispatch` method). */
 export function isProxyDispatcher(value) {
     return (typeof value === 'object' &&
@@ -30,3 +31,85 @@ export function toProxyAgent(proxy) {
     }
     return proxy;
 }
+const TCP_PROXY_HINT = 'socketOptions.proxy.ws must hold an http.Agent-style proxy pointing at an http: url (e.g. new HttpProxyAgent("http://host:port")) to tunnel raw TCP';
+/**
+ * Resolves the proxy endpoint a raw TCP transport tunnels through with HTTP
+ * CONNECT.
+ *
+ * Returns `undefined` only when no proxy is configured. Proxy shapes the tunnel
+ * cannot honour throw instead of resolving to `undefined`, because dropping one
+ * silently would dial the destination directly – the opposite of what a
+ * deployment that pins its egress to a proxy asked for.
+ */
+export function toTcpProxyEndpoint(proxy) {
+    if (!proxy) {
+        return undefined;
+    }
+    if (!isProxyAgent(proxy)) {
+        if (isProxyDispatcher(proxy)) {
+            throw new Error(`undici-style proxy dispatchers cannot tunnel raw TCP – ${TCP_PROXY_HINT}`);
+        }
+        throw new Error(`unsupported proxy transport – ${TCP_PROXY_HINT}`);
+    }
+    const url = readAgentProxyUrl(proxy);
+    if (url.protocol !== 'http:') {
+        throw new Error(`proxy protocol ${url.protocol} is not supported by the raw TCP tunnel – ${TCP_PROXY_HINT}`);
+    }
+    const username = decodeProxyUserInfo(url.username, 'username');
+    const password = decodeProxyUserInfo(url.password, 'password');
+    return {
+        hostname: url.hostname,
+        port: url.port ? Number(url.port) : 80,
+        authorization: username || password
+            ? `Basic ${bytesToBase64(TEXT_ENCODER.encode(`${username}:${password}`))}`
+            : undefined
+    };
+}
+/** Throws when {@link toTcpProxyEndpoint} cannot honour `proxy`. */
+export function assertTcpProxySupported(proxy) {
+    toTcpProxyEndpoint(proxy);
+}
+/**
+ * Decodes one userinfo component of a proxy url. `new URL()` keeps invalid
+ * percent escapes verbatim, so a credential holding a literal `%` would reach
+ * `decodeURIComponent` and throw a bare `URIError`. The value never reaches the
+ * message – only the field name does.
+ */
+function decodeProxyUserInfo(value, field) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        throw new Error(`proxy url ${field} contains a malformed percent escape`);
+    }
+}
+/**
+ * Reads the proxy url an `http.Agent`-style proxy exposes. Every `*-proxy-agent`
+ * package keeps it on `.proxy`, but only the http/https ones store a `URL`
+ * there – `socks-proxy-agent` stores a parsed `{ host, port, type }` endpoint.
+ */
+function readAgentProxyUrl(agent) {
+    const value = agent.proxy;
+    if (value instanceof URL) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            return new URL(value);
+        }
+        catch {
+            throw new Error(`proxy agent exposes an unparseable proxy url ${JSON.stringify(value)}`);
+        }
+    }
+    if (isSocksProxyEndpoint(value)) {
+        throw new Error(`socks proxy agents cannot tunnel raw TCP – ${TCP_PROXY_HINT}`);
+    }
+    throw new Error(`proxy agent exposes no proxy url – ${TCP_PROXY_HINT}`);
+}
+/** Matches the `{ host, port, type }` endpoint `socks-proxy-agent` keeps on `.proxy`. */
+function isSocksProxyEndpoint(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.host === 'string' &&
+        typeof value.port === 'number');
+}

package/dist/message/encode/content.js

@@ -180,7 +180,8 @@ function unwrapMessage(message) {
             msg.viewOnceMessageV2?.message ??
             msg.documentWithCaptionMessage?.message ??
             msg.groupStatusMessage?.message ??
-            msg.groupStatusMessageV2?.message;
+            msg.groupStatusMessageV2?.message ??
+            msg.botForwardedMessage?.message;
         if (!inner)
             return msg;
         msg = inner;
@@ -228,6 +229,8 @@ function resolveMessageTypeAttrFrom(msg) {
         msg.pollResultSnapshotMessageV3 ||
         msg.templateButtonReplyMessage ||
         msg.messageHistoryNotice ||
+        msg.richResponseMessage ||
+        msg.botForwardedMessage ||
         msg.secretEncryptedMessage?.secretEncType ===
             _proto_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT ||
         msg.secretEncryptedMessage?.secretEncType ===

package/dist/transport/node/WaMobileTcpSocket.d.ts

@@ -16,7 +16,9 @@ export declare class WaMobileTcpSocket implements RawWebSocket {
     private closedReason;
     private closedClean;
     private forceCloseTimer;
-    constructor(url: string, _protocols?: unknown, _options?: WaRawWebSocketInit);
+    constructor(url: string, _protocols?: unknown, options?: WaRawWebSocketInit);
+    private markOpen;
+    private emitMessage;
     send(data: string | ArrayBuffer | Uint8Array): void;
     close(code?: number, reason?: string): void;
 }

package/dist/transport/node/WaMobileTcpSocket.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMobileTcpSocketCtor = exports.WaMobileTcpSocket = void 0;
 const node_net_1 = require("node:net");
 const constants_1 = require("../../protocol/constants");
+const proxy_1 = require("../proxy");
 const bytes_1 = require("../../util/bytes");
 /**
  * `RawWebSocket`-shaped adapter over a raw Node TCP socket. Used by the
@@ -10,7 +11,7 @@ const bytes_1 = require("../../util/bytes");
  * `tcp://host:port` URLs.
  */
 class WaMobileTcpSocket {
-    constructor(url, _protocols, _options) {
+    constructor(url, _protocols, options) {
         this.binaryType = 'arraybuffer';
         this.readyState = constants_1.WA_READY_STATES.CONNECTING;
         this.onopen = null;
@@ -22,19 +23,55 @@ class WaMobileTcpSocket {
         this.closedClean = true;
         this.forceCloseTimer = null;
         const { host, port } = parseTcpUrl(url);
-        this.socket = (0, node_net_1.connect)({ host, port });
+        const proxy = (0, proxy_1.toTcpProxyEndpoint)(options?.agent);
+        this.socket = proxy
+            ? (0, node_net_1.connect)({ host: proxy.hostname, port: proxy.port })
+            : (0, node_net_1.connect)({ host, port });
+        let tunnelReady = !proxy;
+        let proxyResponse = new Uint8Array(0);
         this.socket.on('connect', () => {
             if (this.readyState !== constants_1.WA_READY_STATES.CONNECTING)
                 return;
-            this.readyState = constants_1.WA_READY_STATES.OPEN;
-            this.onopen?.({});
+            if (proxy) {
+                const authority = `${host}:${port}`;
+                const lines = [
+                    `CONNECT ${authority} HTTP/1.1`,
+                    `Host: ${authority}`,
+                    'Proxy-Connection: Keep-Alive'
+                ];
+                if (proxy.authorization)
+                    lines.push(`Proxy-Authorization: ${proxy.authorization}`);
+                this.socket.write(bytes_1.TEXT_ENCODER.encode(`${lines.join('\r\n')}\r\n\r\n`));
+                return;
+            }
+            this.markOpen();
         });
         this.socket.on('data', (chunk) => {
-            if (!this.onmessage || this.readyState !== constants_1.WA_READY_STATES.OPEN)
+            if (!tunnelReady && proxy) {
+                proxyResponse = (0, bytes_1.concatBytes)([proxyResponse, chunk]);
+                const headerEnd = findHttpHeaderEnd(proxyResponse);
+                const scanned = headerEnd === -1 ? proxyResponse.byteLength : headerEnd;
+                if (scanned > MAX_PROXY_HEADER_BYTES) {
+                    this.socket.destroy(new Error('WaMobileTcpSocket: proxy response headers too large'));
+                    return;
+                }
+                if (headerEnd === -1) {
+                    return;
+                }
+                const statusLine = bytes_1.TEXT_DECODER.decode(proxyResponse.subarray(0, headerEnd)).split('\r\n')[0];
+                if (!/^HTTP\/1\.[01] 2\d\d(?:\s|$)/.test(statusLine)) {
+                    this.socket.destroy(new Error(`WaMobileTcpSocket: proxy CONNECT failed (${statusLine})`));
+                    return;
+                }
+                const remaining = proxyResponse.subarray(headerEnd + 4);
+                proxyResponse = new Uint8Array(0);
+                tunnelReady = true;
+                this.markOpen();
+                if (remaining.byteLength > 0)
+                    this.emitMessage(remaining);
                 return;
-            const copy = new Uint8Array(chunk.byteLength);
-            copy.set(chunk);
-            this.onmessage({ data: copy });
+            }
+            this.emitMessage(chunk);
         });
         this.socket.on('error', (err) => {
             this.closedClean = false;
@@ -56,6 +93,19 @@ class WaMobileTcpSocket {
             });
         });
     }
+    markOpen() {
+        if (this.readyState !== constants_1.WA_READY_STATES.CONNECTING)
+            return;
+        this.readyState = constants_1.WA_READY_STATES.OPEN;
+        this.onopen?.({});
+    }
+    emitMessage(chunk) {
+        if (!this.onmessage || this.readyState !== constants_1.WA_READY_STATES.OPEN)
+            return;
+        const copy = new Uint8Array(chunk.byteLength);
+        copy.set(chunk);
+        this.onmessage({ data: copy });
+    }
     send(data) {
         if (this.readyState !== constants_1.WA_READY_STATES.OPEN) {
             throw new Error('WaMobileTcpSocket: send() called on non-OPEN socket');
@@ -89,6 +139,16 @@ class WaMobileTcpSocket {
     }
 }
 exports.WaMobileTcpSocket = WaMobileTcpSocket;
+/** Cap on the CONNECT response headers buffered before the tunnel is rejected. */
+const MAX_PROXY_HEADER_BYTES = 65536;
+function findHttpHeaderEnd(bytes) {
+    for (let i = 3; i < bytes.byteLength; i += 1) {
+        if (bytes[i - 3] === 13 && bytes[i - 2] === 10 && bytes[i - 1] === 13 && bytes[i] === 10) {
+            return i - 3;
+        }
+    }
+    return -1;
+}
 function parseTcpUrl(url) {
     let work = url;
     if (work.startsWith('tcp://')) {

package/dist/transport/noise/WaMobileClientPayload.d.ts

@@ -1,5 +1,25 @@
 import { type Proto } from '../../proto';
+/**
+ * Distribution channel advertised by an iOS login (`UserAgent.distributionChannel`).
+ * iOS-only – Android leaves the field unset. `appstore` is the normal
+ * production install; `testflight`/`internal` mark beta builds.
+ */
+export type WaMobileDistributionChannel = 'appstore' | 'website' | 'testflight' | 'internal';
 export interface WaMobileTransportDeviceInfo {
+    /**
+     * Operating system the login payload impersonates. `android` (the default,
+     * for backwards compatibility) advertises the `ANDROID`/`SMB_ANDROID`
+     * platform and fills the Android-only `mcc`/`mnc`/`deviceBoard` fields.
+     * `ios` advertises `IOS`/`SMB_IOS`, omits those Android-only fields (the
+     * real iPhone client never sends them) and carries `distributionChannel`
+     * instead.
+     *
+     * Field mapping differs by OS and must match the real client:
+     * - **Android** `device` = a device codename (e.g. `moto_g52`).
+     * - **iOS** `device` = the marketing name (e.g. `iPhone 15 Pro`) while
+     *   {@link deviceModelType} carries the raw machine id (`iPhone16,1`).
+     */
+    readonly os?: 'android' | 'ios';
     readonly manufacturer: string;
     readonly device: string;
     readonly osVersion: string;
@@ -12,6 +32,8 @@ export interface WaMobileTransportDeviceInfo {
     readonly phoneId?: string;
     readonly deviceBoard?: string;
     readonly deviceModelType?: string;
+    /** iOS distribution channel; ignored for Android. Defaults to `appstore`. */
+    readonly distributionChannel?: WaMobileDistributionChannel;
     readonly business?: boolean;
 }
 export interface WaMobileLoginPayloadConfig {

package/dist/transport/noise/WaMobileClientPayload.js

@@ -16,6 +16,20 @@ function parseAppVersion(version) {
         quaternary: at(3)
     };
 }
+function distributionChannelId(channel) {
+    const { DistributionChannel } = _proto_1.proto.ClientPayload.UserAgent;
+    switch (channel) {
+        case 'website':
+            return DistributionChannel.WEBSITE;
+        case 'testflight':
+            return DistributionChannel.TESTFLIGHT;
+        case 'internal':
+            return DistributionChannel.INTERNAL;
+        case 'appstore':
+        case undefined:
+            return DistributionChannel.APPSTORE;
+    }
+}
 /**
  * Builds the encoded {@link Proto.ClientPayload} bytes the WhatsApp Mobile
  * transport sends after the noise login handshake. Throws when
@@ -27,14 +41,18 @@ function buildMobileLoginPayload(config) {
     }
     const info = config.deviceInfo;
     const version = parseAppVersion(info.appVersion);
-    const userAgent = {
-        platform: info.business
+    const isIos = info.os === 'ios';
+    const platform = isIos
+        ? info.business
+            ? _proto_1.proto.ClientPayload.UserAgent.Platform.SMB_IOS
+            : _proto_1.proto.ClientPayload.UserAgent.Platform.IOS
+        : info.business
             ? _proto_1.proto.ClientPayload.UserAgent.Platform.SMB_ANDROID
-            : _proto_1.proto.ClientPayload.UserAgent.Platform.ANDROID,
+            : _proto_1.proto.ClientPayload.UserAgent.Platform.ANDROID;
+    const userAgent = {
+        platform,
         releaseChannel: _proto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         appVersion: version,
-        mcc: info.mcc ?? '000',
-        mnc: info.mnc ?? '000',
         osVersion: info.osVersion,
         manufacturer: info.manufacturer,
         device: info.device,
@@ -43,8 +61,10 @@ function buildMobileLoginPayload(config) {
         localeLanguageIso6391: info.localeLanguageIso6391 ?? 'en',
         localeCountryIso31661Alpha2: info.localeCountryIso31661Alpha2 ?? 'US',
         deviceType: _proto_1.proto.ClientPayload.UserAgent.DeviceType.PHONE,
-        deviceBoard: info.deviceBoard,
-        deviceModelType: info.deviceModelType
+        deviceModelType: info.deviceModelType,
+        ...(isIos
+            ? { distributionChannel: distributionChannelId(info.distributionChannel) }
+            : { mcc: info.mcc ?? '000', mnc: info.mnc ?? '000', deviceBoard: info.deviceBoard })
     };
     return _proto_1.proto.ClientPayload.encode({
         passive: config.passive === true,

package/dist/transport/proxy.d.ts

@@ -9,3 +9,27 @@ export declare function isProxyTransport(value: unknown): value is WaProxyTransp
 export declare function toProxyDispatcher(proxy: WaProxyTransport | undefined): WaProxyDispatcher | undefined;
 /** Narrows `proxy` to {@link WaProxyAgent} or returns `undefined`. */
 export declare function toProxyAgent(proxy: WaProxyTransport | undefined): WaProxyAgent | undefined;
+/**
+ * HTTP CONNECT endpoint a raw TCP transport dials to reach its destination.
+ *
+ * @sensitive Contains proxy credentials (`authorization`). Never log, serialize
+ * via `JSON.stringify`, or transmit unencrypted. Persist with encryption-at-rest.
+ */
+export interface WaTcpProxyEndpoint {
+    readonly hostname: string;
+    readonly port: number;
+    /** Ready-to-send `Proxy-Authorization` value when the proxy url carries credentials. */
+    readonly authorization?: string;
+}
+/**
+ * Resolves the proxy endpoint a raw TCP transport tunnels through with HTTP
+ * CONNECT.
+ *
+ * Returns `undefined` only when no proxy is configured. Proxy shapes the tunnel
+ * cannot honour throw instead of resolving to `undefined`, because dropping one
+ * silently would dial the destination directly – the opposite of what a
+ * deployment that pins its egress to a proxy asked for.
+ */
+export declare function toTcpProxyEndpoint(proxy: WaProxyTransport | undefined): WaTcpProxyEndpoint | undefined;
+/** Throws when {@link toTcpProxyEndpoint} cannot honour `proxy`. */
+export declare function assertTcpProxySupported(proxy: WaProxyTransport | undefined): void;

package/dist/transport/proxy.js

@@ -5,6 +5,9 @@ exports.isProxyAgent = isProxyAgent;
 exports.isProxyTransport = isProxyTransport;
 exports.toProxyDispatcher = toProxyDispatcher;
 exports.toProxyAgent = toProxyAgent;
+exports.toTcpProxyEndpoint = toTcpProxyEndpoint;
+exports.assertTcpProxySupported = assertTcpProxySupported;
+const bytes_1 = require("../util/bytes");
 /** Type guard for an undici-style proxy dispatcher (has `dispatch` method). */
 function isProxyDispatcher(value) {
     return (typeof value === 'object' &&
@@ -37,3 +40,85 @@ function toProxyAgent(proxy) {
     }
     return proxy;
 }
+const TCP_PROXY_HINT = 'socketOptions.proxy.ws must hold an http.Agent-style proxy pointing at an http: url (e.g. new HttpProxyAgent("http://host:port")) to tunnel raw TCP';
+/**
+ * Resolves the proxy endpoint a raw TCP transport tunnels through with HTTP
+ * CONNECT.
+ *
+ * Returns `undefined` only when no proxy is configured. Proxy shapes the tunnel
+ * cannot honour throw instead of resolving to `undefined`, because dropping one
+ * silently would dial the destination directly – the opposite of what a
+ * deployment that pins its egress to a proxy asked for.
+ */
+function toTcpProxyEndpoint(proxy) {
+    if (!proxy) {
+        return undefined;
+    }
+    if (!isProxyAgent(proxy)) {
+        if (isProxyDispatcher(proxy)) {
+            throw new Error(`undici-style proxy dispatchers cannot tunnel raw TCP – ${TCP_PROXY_HINT}`);
+        }
+        throw new Error(`unsupported proxy transport – ${TCP_PROXY_HINT}`);
+    }
+    const url = readAgentProxyUrl(proxy);
+    if (url.protocol !== 'http:') {
+        throw new Error(`proxy protocol ${url.protocol} is not supported by the raw TCP tunnel – ${TCP_PROXY_HINT}`);
+    }
+    const username = decodeProxyUserInfo(url.username, 'username');
+    const password = decodeProxyUserInfo(url.password, 'password');
+    return {
+        hostname: url.hostname,
+        port: url.port ? Number(url.port) : 80,
+        authorization: username || password
+            ? `Basic ${(0, bytes_1.bytesToBase64)(bytes_1.TEXT_ENCODER.encode(`${username}:${password}`))}`
+            : undefined
+    };
+}
+/** Throws when {@link toTcpProxyEndpoint} cannot honour `proxy`. */
+function assertTcpProxySupported(proxy) {
+    toTcpProxyEndpoint(proxy);
+}
+/**
+ * Decodes one userinfo component of a proxy url. `new URL()` keeps invalid
+ * percent escapes verbatim, so a credential holding a literal `%` would reach
+ * `decodeURIComponent` and throw a bare `URIError`. The value never reaches the
+ * message – only the field name does.
+ */
+function decodeProxyUserInfo(value, field) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        throw new Error(`proxy url ${field} contains a malformed percent escape`);
+    }
+}
+/**
+ * Reads the proxy url an `http.Agent`-style proxy exposes. Every `*-proxy-agent`
+ * package keeps it on `.proxy`, but only the http/https ones store a `URL`
+ * there – `socks-proxy-agent` stores a parsed `{ host, port, type }` endpoint.
+ */
+function readAgentProxyUrl(agent) {
+    const value = agent.proxy;
+    if (value instanceof URL) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            return new URL(value);
+        }
+        catch {
+            throw new Error(`proxy agent exposes an unparseable proxy url ${JSON.stringify(value)}`);
+        }
+    }
+    if (isSocksProxyEndpoint(value)) {
+        throw new Error(`socks proxy agents cannot tunnel raw TCP – ${TCP_PROXY_HINT}`);
+    }
+    throw new Error(`proxy agent exposes no proxy url – ${TCP_PROXY_HINT}`);
+}
+/** Matches the `{ host, port, type }` endpoint `socks-proxy-agent` keeps on `.proxy`. */
+function isSocksProxyEndpoint(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.host === 'string' &&
+        typeof value.port === 'number');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zapo-js",
-    "version": "1.8.2",
+    "version": "1.9.0",
     "description": "High-performance WhatsApp Web TypeScript library",
     "license": "MIT",
     "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",