@zapo-js/fake-server 0.3.0 → 1.0.0

package/dist/esm/api/AppStateSyncManager.js

@@ -0,0 +1,146 @@
+import { buildServerSyncNotification } from '../protocol/iq/appstate-sync.js';
+import { FakeAppStateCrypto } from '../protocol/signal/fake-app-state-crypto.js';
+import { proto } from '../transport/protos.js';
+function toHex(bytes) {
+    let out = '';
+    for (let index = 0; index < bytes.byteLength; index += 1) {
+        const value = bytes[index];
+        out += value < 16 ? `0${value.toString(16)}` : value.toString(16);
+    }
+    return out;
+}
+export class AppStateSyncManager {
+    constructor() {
+        this.appStateCollectionProviders = new Map();
+        this.appStateSyncKeysByKeyId = new Map();
+        this.appStateCrypto = new FakeAppStateCrypto();
+        this.outboundMutationListeners = new Set();
+    }
+    registerAppStateSyncKey(keyId, keyData) {
+        this.appStateSyncKeysByKeyId.set(toHex(keyId), keyData);
+    }
+    onOutboundAppStateMutation(listener) {
+        this.outboundMutationListeners.add(listener);
+        return () => {
+            this.outboundMutationListeners.delete(listener);
+        };
+    }
+    expectAppStateMutation(predicate, timeoutMs = 15000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                unsubscribe();
+                reject(new Error(`expectAppStateMutation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const unsubscribe = this.onOutboundAppStateMutation((mutation) => {
+                if (!predicate(mutation))
+                    return;
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(mutation);
+            });
+        });
+    }
+    provideAppStateCollection(name, provider) {
+        this.appStateCollectionProviders.set(name, provider);
+        return () => {
+            this.appStateCollectionProviders.delete(name);
+        };
+    }
+    async pushServerSyncNotification(pipeline, input) {
+        await pipeline.sendStanza(buildServerSyncNotification(input));
+    }
+    async consumeOutboundAppStatePatches(iq) {
+        if (!Array.isArray(iq.content))
+            return;
+        const sync = iq.content.find((child) => child.tag === 'sync');
+        if (!sync || !Array.isArray(sync.content))
+            return;
+        for (const collectionNode of sync.content) {
+            if (collectionNode.tag !== 'collection')
+                continue;
+            if (!Array.isArray(collectionNode.content))
+                continue;
+            const collectionName = collectionNode.attrs.name;
+            if (!collectionName)
+                continue;
+            for (const patchNode of collectionNode.content) {
+                if (patchNode.tag !== 'patch')
+                    continue;
+                const patchBytes = patchNode.content;
+                if (!(patchBytes instanceof Uint8Array))
+                    continue;
+                try {
+                    const decoded = proto.SyncdPatch.decode(patchBytes);
+                    const keyId = decoded.keyId?.id;
+                    if (!keyId)
+                        continue;
+                    const keyData = this.appStateSyncKeysByKeyId.get(toHex(keyId));
+                    if (!keyData)
+                        continue;
+                    const rawVersion = decoded.version?.version;
+                    let patchVersion = 0;
+                    if (typeof rawVersion === 'number') {
+                        patchVersion = rawVersion;
+                    }
+                    else if (rawVersion !== null &&
+                        rawVersion !== undefined &&
+                        typeof rawVersion.toNumber === 'function') {
+                        patchVersion = rawVersion.toNumber();
+                    }
+                    for (const mutation of decoded.mutations ?? []) {
+                        const operationCode = mutation.operation;
+                        if (operationCode === null || operationCode === undefined)
+                            continue;
+                        const record = mutation.record;
+                        if (!record)
+                            continue;
+                        const indexMac = record.index?.blob;
+                        const valueBlob = record.value?.blob;
+                        if (!indexMac || !valueBlob)
+                            continue;
+                        const operation = operationCode === proto.SyncdMutation.SyncdOperation.REMOVE
+                            ? 'remove'
+                            : 'set';
+                        const decrypted = await this.appStateCrypto.decryptMutation({
+                            operation,
+                            keyId,
+                            keyData,
+                            indexMac,
+                            valueBlob
+                        });
+                        let action;
+                        try {
+                            const parsed = JSON.parse(decrypted.index);
+                            if (Array.isArray(parsed) && typeof parsed[0] === 'string') {
+                                action = parsed[0];
+                            }
+                        }
+                        catch {
+                            // Ignore malformed index payloads; mutation capture still proceeds.
+                        }
+                        const captured = {
+                            collection: collectionName,
+                            operation,
+                            index: decrypted.index,
+                            action,
+                            version: decrypted.version,
+                            value: decrypted.value,
+                            patchVersion
+                        };
+                        for (const listener of this.outboundMutationListeners) {
+                            try {
+                                listener(captured);
+                            }
+                            catch {
+                                // Listener failures are best-effort.
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore malformed/undecryptable patches.
+                }
+            }
+        }
+    }
+}

package/dist/esm/api/FakePairingDriver.js

@@ -0,0 +1,31 @@
+/** Runs the server side of the QR pairing flow. */
+import { buildAdvSignedDeviceIdentity, generateFakePrimaryDevice } from '../protocol/auth/fake-primary-device.js';
+import { buildPairDeviceIq, buildPairSuccessIq } from '../protocol/auth/pair-device.js';
+import { randomBytesAsync } from '../transport/crypto.js';
+export class FakePairingDriver {
+    constructor(options, deps) {
+        this.primary = null;
+        this.options = options;
+        this.deps = deps;
+    }
+    async run() {
+        this.primary = this.options.primary ?? (await generateFakePrimaryDevice());
+        const refs = await Promise.all(Array.from({ length: 6 }, () => randomBytesAsync(16)));
+        const pairDeviceIq = buildPairDeviceIq({ refs });
+        await this.deps.pipeline.sendStanza(pairDeviceIq);
+        const waitForAck = this.deps.waitForPairDeviceAck?.(pairDeviceIq.attrs.id) ?? Promise.resolve();
+        const [material] = await Promise.all([this.deps.companionMaterialResolver(), waitForAck]);
+        const { deviceIdentityBytes } = await buildAdvSignedDeviceIdentity({
+            primary: this.primary,
+            advSecretKey: material.advSecretKey,
+            companionIdentityPublicKey: material.identityPublicKey,
+            companionDeviceId: this.options.companionDeviceId ?? 1
+        });
+        await this.deps.pipeline.sendStanza(buildPairSuccessIq({
+            deviceJid: this.options.deviceJid,
+            deviceLid: this.options.deviceLid,
+            platform: this.options.platform ?? 'IOS',
+            deviceIdentityBytes
+        }));
+    }
+}