@zapo-js/fake-server 0.3.0 → 1.1.0

package/dist/esm/protocol/iq/appstate-sync.js

@@ -0,0 +1,146 @@
+/** App-state sync IQ/notification builders used by the fake server. */
+import { proto } from '../../transport/protos.js';
+import { buildIqResult } from './router.js';
+/** Encodes `ExternalBlobReference` used by external snapshot downloads. */
+export function buildExternalBlobReference(input) {
+    return proto.ExternalBlobReference.encode({
+        mediaKey: input.mediaKey,
+        directPath: input.directPath,
+        fileSha256: input.fileSha256,
+        fileEncSha256: input.fileEncSha256,
+        fileSizeBytes: input.fileSizeBytes
+    }).finish();
+}
+export function parseAppStateSyncRequest(iq) {
+    if (iq.tag !== 'iq')
+        return [];
+    if (!Array.isArray(iq.content))
+        return [];
+    const sync = iq.content.find((child) => child.tag === 'sync');
+    if (!sync || !Array.isArray(sync.content))
+        return [];
+    const out = [];
+    for (const child of sync.content) {
+        if (child.tag !== 'collection')
+            continue;
+        const name = child.attrs.name;
+        if (!name)
+            continue;
+        const versionAttr = child.attrs.version;
+        const version = versionAttr ? Number.parseInt(versionAttr, 10) : 0;
+        out.push({
+            name,
+            version: Number.isFinite(version) ? version : 0
+        });
+    }
+    return out;
+}
+export function buildAppStateSyncResult(iq, input = {}) {
+    const requests = parseAppStateSyncRequest(iq);
+    const versions = input.versions ?? {};
+    const collectionNodes = requests.map((entry) => {
+        const overriddenVersion = versions[entry.name];
+        const responseVersion = overriddenVersion ?? entry.version;
+        return {
+            tag: 'collection',
+            attrs: {
+                name: entry.name,
+                version: String(responseVersion),
+                type: 'result'
+            }
+        };
+    });
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        attrs: { ...result.attrs, from: 's.whatsapp.net' },
+        content: [
+            {
+                tag: 'sync',
+                attrs: {},
+                content: collectionNodes
+            }
+        ]
+    };
+}
+export function buildAppStateSyncFullResult(iq, input) {
+    const requests = parseAppStateSyncRequest(iq);
+    const payloadsByName = new Map();
+    for (const payload of input.payloads) {
+        payloadsByName.set(payload.name, payload);
+    }
+    const collectionNodes = requests.map((request) => {
+        const payload = payloadsByName.get(request.name);
+        if (!payload) {
+            return {
+                tag: 'collection',
+                attrs: {
+                    name: request.name,
+                    version: String(request.version),
+                    type: 'result'
+                }
+            };
+        }
+        const children = [];
+        if (payload.snapshot && payload.patches) {
+            throw new Error(`app-state collection ${request.name}: snapshot and patches are mutually exclusive`);
+        }
+        if (payload.snapshot) {
+            children.push({
+                tag: 'snapshot',
+                attrs: {},
+                content: payload.snapshot
+            });
+        }
+        if (payload.patches && payload.patches.length > 0) {
+            children.push({
+                tag: 'patches',
+                attrs: {},
+                content: payload.patches.map((patchBytes) => ({
+                    tag: 'patch',
+                    attrs: {},
+                    content: patchBytes
+                }))
+            });
+        }
+        const attrs = {
+            name: request.name,
+            version: String(payload.version),
+            type: 'result'
+        };
+        if (payload.hasMore) {
+            attrs.has_more_patches = 'true';
+        }
+        return {
+            tag: 'collection',
+            attrs,
+            content: children.length > 0 ? children : undefined
+        };
+    });
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        attrs: { ...result.attrs, from: 's.whatsapp.net' },
+        content: [
+            {
+                tag: 'sync',
+                attrs: {},
+                content: collectionNodes
+            }
+        ]
+    };
+}
+export function buildServerSyncNotification(input) {
+    return {
+        tag: 'notification',
+        attrs: {
+            id: input.id ?? `server-sync-${Date.now()}`,
+            type: 'server_sync',
+            from: 's.whatsapp.net'
+        },
+        content: input.collections.map((name) => ({
+            tag: 'collection',
+            attrs: { name }
+        }))
+    };
+}

package/dist/esm/protocol/iq/business.js

@@ -0,0 +1,59 @@
+/** Builders/parsers for `w:biz` business profile IQs. */
+import { buildIqResult } from './router.js';
+export function buildBusinessProfileResult(iq, profiles) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'business_profile',
+                attrs: { v: '116' },
+                content: profiles.map((profile) => ({
+                    tag: 'profile',
+                    attrs: { jid: profile.jid, tag: 'fake-profile-tag' },
+                    content: buildBusinessProfileChildren(profile)
+                }))
+            }
+        ]
+    };
+}
+function buildBusinessProfileChildren(profile) {
+    const out = [];
+    if (profile.address !== undefined) {
+        out.push({ tag: 'address', attrs: {}, content: profile.address });
+    }
+    if (profile.description !== undefined) {
+        out.push({ tag: 'description', attrs: {}, content: profile.description });
+    }
+    if (profile.email !== undefined) {
+        out.push({ tag: 'email', attrs: {}, content: profile.email });
+    }
+    for (const website of profile.websites ?? []) {
+        out.push({ tag: 'website', attrs: {}, content: website });
+    }
+    if (profile.categoryIds && profile.categoryIds.length > 0) {
+        out.push({
+            tag: 'categories',
+            attrs: {},
+            content: profile.categoryIds.map((id) => ({
+                tag: 'category',
+                attrs: { id }
+            }))
+        });
+    }
+    return out;
+}
+export function parseGetBusinessProfileIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const profile = iq.content.find((child) => child.tag === 'business_profile');
+    if (!profile || !Array.isArray(profile.content))
+        return null;
+    const jids = [];
+    for (const child of profile.content) {
+        if (child.tag === 'profile' && child.attrs.jid) {
+            jids.push(child.attrs.jid);
+        }
+    }
+    return jids;
+}

package/dist/esm/protocol/iq/dirty-bits.js

@@ -0,0 +1,19 @@
+/** Parser for `urn:xmpp:whatsapp:dirty` clear IQs. */
+export function parseClearDirtyBitsIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const out = [];
+    for (const child of iq.content) {
+        if (child.tag !== 'clean')
+            continue;
+        const type = child.attrs.type;
+        const timestamp = child.attrs.timestamp;
+        if (!type || !timestamp)
+            continue;
+        const parsed = Number.parseInt(timestamp, 10);
+        if (!Number.isFinite(parsed))
+            continue;
+        out.push({ type, timestamp: parsed });
+    }
+    return out.length > 0 ? out : null;
+}

package/dist/esm/protocol/iq/group-ops.js

@@ -0,0 +1,154 @@
+/** Builders/parsers for `w:g2` group IQ operations. */
+import { buildIqResult } from './router.js';
+export function parseGroupParticipantChangeIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    for (const child of iq.content) {
+        if (child.tag === 'add' ||
+            child.tag === 'remove' ||
+            child.tag === 'promote' ||
+            child.tag === 'demote') {
+            const groupJid = iq.attrs.to;
+            if (!groupJid)
+                return null;
+            const participantJids = [];
+            if (Array.isArray(child.content)) {
+                for (const participant of child.content) {
+                    if (participant.tag === 'participant' && participant.attrs.jid) {
+                        participantJids.push(participant.attrs.jid);
+                    }
+                }
+            }
+            return {
+                action: child.tag,
+                groupJid,
+                participantJids
+            };
+        }
+    }
+    return null;
+}
+export function buildGroupParticipantChangeResult(iq, action, participantJids) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: action,
+                attrs: {},
+                content: participantJids.map((jid) => ({
+                    tag: 'participant',
+                    attrs: { jid, error: '200' }
+                }))
+            }
+        ]
+    };
+}
+export function parseCreateGroupIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const create = iq.content.find((child) => child.tag === 'create');
+    if (!create)
+        return null;
+    const subject = create.attrs.subject ?? '';
+    const participantJids = [];
+    let description;
+    if (Array.isArray(create.content)) {
+        for (const child of create.content) {
+            if (child.tag === 'participant' && child.attrs.jid) {
+                participantJids.push(child.attrs.jid);
+            }
+            else if (child.tag === 'description' && Array.isArray(child.content)) {
+                const body = child.content.find((c) => c.tag === 'body');
+                if (body && typeof body.content === 'string') {
+                    description = body.content;
+                }
+                else if (body && body.content instanceof Uint8Array) {
+                    description = new TextDecoder().decode(body.content);
+                }
+            }
+        }
+    }
+    return { subject, participantJids, description };
+}
+export function parseSetSubjectIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const subject = iq.content.find((child) => child.tag === 'subject');
+    if (!subject)
+        return null;
+    const groupJid = iq.attrs.to;
+    if (!groupJid)
+        return null;
+    return {
+        groupJid,
+        subject: decodeNodeContentToString(subject.content) ?? ''
+    };
+}
+export function parseSetDescriptionIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const desc = iq.content.find((child) => child.tag === 'description');
+    if (!desc)
+        return null;
+    const groupJid = iq.attrs.to;
+    if (!groupJid)
+        return null;
+    if (desc.attrs.delete === 'true') {
+        return { groupJid, description: null, descriptionId: desc.attrs.id };
+    }
+    let body = null;
+    if (Array.isArray(desc.content)) {
+        const bodyNode = desc.content.find((c) => c.tag === 'body');
+        if (bodyNode) {
+            body = decodeNodeContentToString(bodyNode.content) ?? '';
+        }
+    }
+    return { groupJid, description: body, descriptionId: desc.attrs.id };
+}
+export function parseLeaveGroupIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const leave = iq.content.find((child) => child.tag === 'leave');
+    if (!leave || !Array.isArray(leave.content))
+        return null;
+    const out = [];
+    for (const child of leave.content) {
+        if (child.tag === 'group' && child.attrs.id) {
+            out.push(child.attrs.id);
+        }
+    }
+    return out;
+}
+export function buildGroupMetadataNode(input) {
+    const children = input.participantJids.map((jid) => ({
+        tag: 'participant',
+        attrs: { jid }
+    }));
+    if (input.description !== undefined) {
+        children.push({
+            tag: 'description',
+            attrs: { id: input.descriptionId ?? `${Date.now()}` },
+            content: [{ tag: 'body', attrs: {}, content: input.description }]
+        });
+    }
+    return {
+        tag: 'group',
+        attrs: {
+            id: input.groupJid,
+            subject: input.subject,
+            creation: String(input.creationSeconds),
+            creator: input.creator,
+            s_t: String(input.creationSeconds),
+            s_o: input.creator
+        },
+        content: children
+    };
+}
+function decodeNodeContentToString(content) {
+    if (typeof content === 'string')
+        return content;
+    if (content instanceof Uint8Array)
+        return new TextDecoder().decode(content);
+    return undefined;
+}

package/dist/esm/protocol/iq/newsletter.js

@@ -0,0 +1,14 @@
+/** Builds the `newsletter/my_addons` IQ result expected by the lib. */
+import { buildIqResult } from './router.js';
+export function buildNewsletterMyAddonsResult(iq) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'my_addons',
+                attrs: {}
+            }
+        ]
+    };
+}

package/dist/esm/protocol/iq/prekey-fetch.js

@@ -0,0 +1,88 @@
+/** Builder for `encrypt` prekey-fetch IQ responses. */
+export function buildPreKeyFetchResult(inboundIq, bundles) {
+    const id = inboundIq.attrs.id;
+    if (!id) {
+        throw new Error('cannot build prekey-fetch result without an inbound id');
+    }
+    const userNodes = bundles.map((bundle) => {
+        const children = [
+            {
+                tag: 'registration',
+                attrs: {},
+                content: bigEndianBytes(bundle.registrationId, 4)
+            },
+            {
+                tag: 'identity',
+                attrs: {},
+                content: bundle.identityPublicKey
+            },
+            {
+                tag: 'skey',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'id',
+                        attrs: {},
+                        content: bigEndianBytes(bundle.signedPreKey.id, 3)
+                    },
+                    {
+                        tag: 'value',
+                        attrs: {},
+                        content: bundle.signedPreKey.publicKey
+                    },
+                    {
+                        tag: 'signature',
+                        attrs: {},
+                        content: bundle.signedPreKey.signature
+                    }
+                ]
+            }
+        ];
+        if (bundle.oneTimePreKey) {
+            children.push({
+                tag: 'key',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'id',
+                        attrs: {},
+                        content: bigEndianBytes(bundle.oneTimePreKey.id, 3)
+                    },
+                    {
+                        tag: 'value',
+                        attrs: {},
+                        content: bundle.oneTimePreKey.publicKey
+                    }
+                ]
+            });
+        }
+        return {
+            tag: 'user',
+            attrs: { jid: bundle.userJid },
+            content: children
+        };
+    });
+    return {
+        tag: 'iq',
+        attrs: {
+            id,
+            from: inboundIq.attrs.to ?? 's.whatsapp.net',
+            type: 'result'
+        },
+        content: [
+            {
+                tag: 'list',
+                attrs: {},
+                content: userNodes
+            }
+        ]
+    };
+}
+function bigEndianBytes(value, length) {
+    const out = new Uint8Array(length);
+    for (let i = length - 1; i >= 0; i -= 1) {
+        out[i] = value & 0xff;
+        value >>>= 8;
+    }
+    return out;
+}

package/dist/esm/protocol/iq/privacy-token.js

@@ -0,0 +1,26 @@
+/** Parser helpers for outbound trusted-contact privacy token IQs. */
+export function parsePrivacyTokenIssueIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const tokens = iq.content.find((child) => child.tag === 'tokens');
+    if (!tokens || !Array.isArray(tokens.content))
+        return null;
+    const out = [];
+    for (const child of tokens.content) {
+        if (child.tag !== 'token')
+            continue;
+        const jid = child.attrs.jid;
+        const t = child.attrs.t;
+        if (!jid || !t)
+            continue;
+        const timestampS = Number.parseInt(t, 10);
+        if (!Number.isFinite(timestampS))
+            continue;
+        out.push({
+            jid,
+            timestampS,
+            type: child.attrs.type ?? 'trusted_contact'
+        });
+    }
+    return out;
+}

package/dist/esm/protocol/iq/privacy.js

@@ -0,0 +1,123 @@
+/** Builders/parsers for `privacy` and `blocklist` IQs. */
+import { buildIqResult } from './router.js';
+export const FAKE_DEFAULT_PRIVACY_SETTINGS = Object.freeze({
+    settings: Object.freeze({
+        readreceipts: 'all',
+        last: 'all',
+        online: 'all',
+        profile: 'all',
+        status: 'contacts',
+        groupadd: 'all',
+        calladd: 'all',
+        messages: 'all',
+        defense: 'off'
+    }),
+    disallowed: Object.freeze({
+        readreceipts: Object.freeze([]),
+        last: Object.freeze([]),
+        online: Object.freeze([]),
+        profile: Object.freeze([]),
+        status: Object.freeze([]),
+        groupadd: Object.freeze([]),
+        calladd: Object.freeze([]),
+        messages: Object.freeze([]),
+        defense: Object.freeze([])
+    })
+});
+export function buildPrivacySettingsResult(iq, state) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'privacy',
+                attrs: {},
+                content: Object.keys(state.settings).map((name) => ({
+                    tag: 'category',
+                    attrs: { name, value: state.settings[name] }
+                }))
+            }
+        ]
+    };
+}
+export function buildPrivacyDisallowedListResult(iq, category, jids) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'privacy',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'list',
+                        attrs: {
+                            name: category,
+                            value: 'contact_blacklist',
+                            dhash: 'fake-dhash'
+                        },
+                        content: jids.map((jid) => ({
+                            tag: 'user',
+                            attrs: { jid }
+                        }))
+                    }
+                ]
+            }
+        ]
+    };
+}
+export function buildBlocklistResult(iq, jids) {
+    const result = buildIqResult(iq);
+    return {
+        ...result,
+        content: [
+            {
+                tag: 'list',
+                attrs: { dhash: 'fake-blocklist-dhash' },
+                content: jids.map((jid) => ({
+                    tag: 'item',
+                    attrs: { jid }
+                }))
+            }
+        ]
+    };
+}
+export function parsePrivacySetCategoryIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const privacy = iq.content.find((child) => child.tag === 'privacy');
+    if (!privacy || !Array.isArray(privacy.content))
+        return null;
+    const category = privacy.content.find((child) => child.tag === 'category');
+    if (!category)
+        return null;
+    const name = category.attrs.name;
+    const value = category.attrs.value;
+    if (!name || !value)
+        return null;
+    return { category: name, value };
+}
+export function parseBlocklistChangeIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const item = iq.content.find((child) => child.tag === 'item');
+    if (!item)
+        return null;
+    const jid = item.attrs.jid;
+    const action = item.attrs.action;
+    if (!jid || (action !== 'block' && action !== 'unblock'))
+        return null;
+    return { jid, action };
+}
+export function parsePrivacyDisallowedListGetIq(iq) {
+    if (!Array.isArray(iq.content))
+        return null;
+    const privacy = iq.content.find((child) => child.tag === 'privacy');
+    if (!privacy || !Array.isArray(privacy.content))
+        return null;
+    const list = privacy.content.find((child) => child.tag === 'list');
+    if (!list)
+        return null;
+    const name = list.attrs.name;
+    return name ?? null;
+}