plogme 1.0.0

package/lib/Utils/integrity.js

@@ -0,0 +1,296 @@
+/**
+ * Package integrity & attribution guard.
+ *
+ * Verifies at runtime that this copy is the genuine, un-rebranded
+ * `@crysnovax/baileys` distribution and that the attribution-required
+ * license is intact. If the package identity has been renamed/stripped
+ * (the usual result of AI-assisted rebranding), premium features are
+ * disabled with a loud warning so the stolen copy visibly degrades
+ * instead of quietly becoming a "free rebrand".
+ *
+ * A remote attestation layer sits on top: on socket connect the client
+ * phones home to bailey.crysnovax.link with its package identity and a
+ * machine fingerprint. The worker answers "genuine", "revoked", or
+ * "rebranded"; "revoked" / "rebranded" disable premium features and can
+ * be issued remotely by the operator at any time.
+ *
+ * DEVELOPER ESCAPE HATCH (so the maintainer never locks themself out):
+ *   Set CRYSNOVAX_TRUST_MODE=1 in the environment to bypass the local
+ *   integrity checks entirely. Use this when you are actively editing
+ *   the package (e.g. with an AI assistant) and a check trips on a
+ *   legitimate edit. Rebranders can set it too — but at that point they
+ *   are deliberately tampering, which the license already prohibits.
+ *
+ * Anti-evasion notes:
+ *  - The expected identity is stored ENCODED and only decoded at runtime,
+ *    so naive find-and-replace / "remove every mention of crysnovax"
+ *    rewrites miss it.
+ *  - This module is imported from several unrelated entry points
+ *    (socket factory, base socket, message composer, message sender), so
+ *    removing one hook leaves the others active.
+ *  - The checks never throw and never break legitimate installs: a
+ *    manifest that cannot be read — or a worker that cannot be reached —
+ *    is treated as genuine rather than risking false-positive degradation.
+ */
+import { readFileSync } from 'fs';
+import { createHash } from 'node:crypto';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+import { DONATE_URL, LIBRARY_NAME } from '../Defaults/index.js';
+
+const nodeRequire = createRequire(import.meta.url);
+const decode = b64 => Buffer.from(b64, 'base64').toString('utf8');
+
+// ─── Encoded brand identity (decoded below at runtime) ──────────────────────
+const EXPECTED = {
+    // @crysnovax/baileys
+    name: 'QGNyeXNub3ZheC9iYWlsZXlz',
+    // crysnovax
+    author: 'Y3J5c25vdmF4',
+    // https://web.crysnovax.link
+    site: 'aHR0cHM6Ly93ZWIuY3J5c25vdmF4Lmxpbms=',
+    // SEE LICENSE IN LICENSE
+    licenseId: 'U0VFIExJQ0VOU0UgSU4gTElDRU5TRQ==',
+    // crysnovax/bailey
+    libraryName: 'Y3J5c25vdmF4L2JhaWxleQ==',
+    // Crysnovax Source License v1.0 (canary phrase inside LICENSE)
+    licenseCanary: 'Q3J5c25vdmF4IFNvdXJjZSBMaWNlbnNlIHYxLjA=',
+    // https://bailey.crysnovax.link/api/v1/verify
+    verifyUrl: 'aHR0cHM6Ly9iYWlsZXkuY3J5c25vdmF4LmxpbmsvYXBpL3YxL3ZlcmlmeQ=='
+};
+
+/** Public brand string used for messages (decoded once). */
+export const getBrandName = () => decode(EXPECTED.name);
+
+/** Developer escape hatch — set to '1' while actively editing the package. */
+export const isTrustMode = () => process.env.CRYSNOVAX_TRUST_MODE === '1';
+
+let cachedReport = null;
+
+/**
+ * Returns { genuine, reasons, warnings } for this copy. Memoized per process.
+ * - CRYSNOVAX_TRUST_MODE=1                      → genuine (developer mode)
+ * - manifest readable + all checks pass         → genuine: true
+ * - manifest readable + identity mismatch       → genuine: false (reasons)
+ * - cosmetic drift (URL/canary touched)         → genuine: true (warnings only)
+ * - manifest unreadable (unusual packaging)     → genuine: true (no false positives)
+ */
+export const getIntegrityReport = () => {
+    if (cachedReport) {
+        return cachedReport;
+    }
+    if (isTrustMode()) {
+        cachedReport = {
+            genuine: true,
+            reasons: ['trust mode'],
+            warnings: ['CRYSNOVAX_TRUST_MODE=1 is set — integrity checks bypassed (developer mode)']
+        };
+        return cachedReport;
+    }
+    const reasons = [];
+    const warnings = [];
+    let manifest = null;
+    try {
+        // lib/Utils/integrity.js → ../../package.json = package root manifest
+        manifest = nodeRequire('../../package.json');
+    }
+    catch {
+        // manifest not resolvable — never degrade on packaging oddities alone
+    }
+    if (manifest) {
+        const author = typeof manifest.author === 'string'
+            ? manifest.author
+            : manifest.author?.name;
+        // Hard identity checks — these are what define a rebrand.
+        if (manifest.name !== decode(EXPECTED.name)) {
+            reasons.push(`package renamed to "${manifest.name}"`);
+        }
+        if (author !== decode(EXPECTED.author)) {
+            reasons.push('author attribution removed');
+        }
+        if (manifest.license !== decode(EXPECTED.licenseId)) {
+            reasons.push(`license swapped to "${manifest.license}"`);
+        }
+    }
+    // LICENSE file must exist and carry the license identifier canary
+    try {
+        const licenseText = readFileSync(new URL('../../LICENSE', import.meta.url), 'utf8');
+        if (!licenseText.includes(decode(EXPECTED.licenseCanary))) {
+            // Missing canary = likely edited LICENSE; still licensable, so warn
+            warnings.push('license file was edited (canary phrase missing)');
+        }
+    }
+    catch {
+        reasons.push('license file missing');
+    }
+    // Brand constants — cosmetic drift warns but never disables features,
+    // so maintainers editing defaults with an AI don't lock themselves out.
+    if (DONATE_URL !== decode(EXPECTED.site)) {
+        warnings.push('attribution URL changed');
+    }
+    if (LIBRARY_NAME !== decode(EXPECTED.libraryName)) {
+        warnings.push('library identity constant changed');
+    }
+    cachedReport = {
+        genuine: reasons.length === 0,
+        reasons,
+        warnings
+    };
+    return cachedReport;
+};
+
+let rebrandWarned = false;
+let warningsShown = false;
+
+/**
+ * Logs a loud, one-time warning when this copy fails the integrity check.
+ * Also surfaces cosmetic warnings once (genuine but drifted) so the
+ * maintainer knows a check was soft-tripped. Returns the report.
+ */
+export const warnIfRebranded = (logger) => {
+    const report = getIntegrityReport();
+    if (!report.warnings.length && !rebrandWarned) {
+        return report;
+    }
+    const log = (level, message) => {
+        if (logger && typeof logger[level] === 'function') {
+            logger[level]({ reasons: report.reasons, warnings: report.warnings }, message);
+        }
+        else {
+            console.warn('\n' + message + '\n');
+        }
+    };
+    if (report.warnings.length && !warningsShown) {
+        warningsShown = true;
+        log('warn',
+            `⚙ ${getBrandName()} integrity: ${report.warnings.join('; ')}. ` +
+            `Features stay enabled; if this was an accidental edit, set CRYSNOVAX_TRUST_MODE=1 while developing.`);
+    }
+    if (!report.genuine && !rebrandWarned) {
+        rebrandWarned = true;
+        log('warn',
+            `✖ UNAUTHORIZED REBRANDED COPY DETECTED — this is not an official ` +
+            `${getBrandName()} distribution (${report.reasons.join('; ')}). ` +
+            `Rebranding or removing attribution violates the ${decode(EXPECTED.licenseCanary)}. ` +
+            `Premium features are disabled on this copy. Install the genuine package: ` +
+            `https://www.npmjs.com/package/${getBrandName()}`);
+    }
+    return report;
+};
+
+// ─── Remote attestation (bailey.crysnovax.link) ─────────────────────────────
+
+let fingerprint = null;
+const getFingerprint = () => {
+    if (fingerprint) {
+        return fingerprint;
+    }
+    const cpu = os.cpus?.()?.[0]?.model || 'unknown-cpu';
+    const raw = [
+        os.hostname(),
+        os.platform(),
+        os.arch(),
+        cpu,
+        process.version
+    ].join('|');
+    fingerprint = createHash('sha256').update(raw).digest('hex').slice(0, 32);
+    return fingerprint;
+};
+
+let remoteRevoked = false;
+let remoteChecked = false;
+let remoteError = false;
+let remoteWarned = false;
+
+/** Current remote state: 'genuine' | 'revoked' | 'unknown'. */
+export const getRemoteStatus = () => {
+    if (!remoteChecked || remoteError) {
+        return 'unknown';
+    }
+    return remoteRevoked ? 'revoked' : 'genuine';
+};
+
+/**
+ * Phones home once per process. NEVER throws and FAILS OPEN: any network
+ * error, timeout, or malformed reply leaves premium features enabled —
+ * only an explicit revoked/rebranded verdict disables them.
+ */
+export const refreshRemoteStatus = async (logger) => {
+    if (remoteChecked) {
+        return getRemoteStatus();
+    }
+    remoteChecked = true;
+    try {
+        let pkg = null;
+        let version = '';
+        try {
+            pkg = nodeRequire('../../package.json');
+            version = pkg?.version || '';
+        }
+        catch {
+            // manifest unreadable — still send what we know
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 4000);
+        try {
+            const res = await fetch(decode(EXPECTED.verifyUrl), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    package: pkg?.name || '',
+                    version,
+                    fingerprint: getFingerprint()
+                }),
+                signal: controller.signal
+            });
+            if (!res.ok) {
+                remoteError = true;
+                return 'unknown';
+            }
+            const body = await res.json();
+            if (body?.status === 'revoked' || body?.status === 'rebranded') {
+                remoteRevoked = true;
+                if (!remoteWarned) {
+                    remoteWarned = true;
+                    const message = `✖ THIS INSTALL HAS BEEN REVOKED (${body.status}) — premium features are disabled.`;
+                    if (logger && typeof logger.warn === 'function') {
+                        logger.warn({ status: body.status }, message);
+                    }
+                    else {
+                        console.warn('\n' + message + '\n');
+                    }
+                }
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        // fail open — network error/timeout never bricks a genuine install
+        remoteError = true;
+    }
+    return getRemoteStatus();
+};
+
+/**
+ * Gate for premium features: returns true only on a genuine copy that has
+ * not been remotely revoked. On a rebranded/revoked copy, warns once and
+ * returns false so the feature degrades to its non-premium behavior.
+ */
+export const premiumEnabled = (logger) => {
+    // Remote revocation wins (its warning was already emitted by refreshRemoteStatus)
+    if (remoteRevoked) {
+        return false;
+    }
+    const report = getIntegrityReport();
+    if (!report.genuine) {
+        warnIfRebranded(logger);
+        return false;
+    }
+    // Genuine but drifted — surface the warnings once, keep features on
+    if (report.warnings.length) {
+        warnIfRebranded(logger);
+    }
+    return true;
+};

package/lib/Utils/jid-display-normalization.js

@@ -0,0 +1,209 @@
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode } from '../WABinary/index.js';
+
+const createLidPnDebug = (logger) => {
+    const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true';
+    return (phase, payload) => {
+        if (!enabled) {
+            return;
+        }
+        logger?.debug({ ...payload, phase }, 'lid->pn normalization trace');
+    };
+};
+
+const fallbackPnFromLidJid = (jid) => {
+    const decoded = jidDecode(jid);
+    const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '');
+    const user = rawUser.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    return `${user}@s.whatsapp.net`;
+};
+
+const toDisplayPnJid = (jid) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    const decoded = jidDecode(jid);
+    if (!decoded?.user) {
+        return jid;
+    }
+    if (!isPnUser(jid) && !isHostedPnUser(jid)) {
+        return jid;
+    }
+    const user = decoded.user.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net';
+    return `${user}@${server}`;
+};
+
+const buildLidPnHints = (key) => {
+    const hints = new Map();
+    if (!key) {
+        return hints;
+    }
+    const addHint = (lid, pn) => {
+        if (!isLidUser(lid) && !isHostedLidUser(lid)) {
+            return;
+        }
+        if (!isPnUser(pn) && !isHostedPnUser(pn)) {
+            return;
+        }
+        hints.set(lid, pn);
+        const lidDecoded = jidDecode(lid);
+        const pnDecoded = jidDecode(pn);
+        if (lidDecoded?.user && pnDecoded?.user) {
+            hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`);
+        }
+    };
+    addHint(key.participant, key.participantAlt);
+    addHint(key.remoteJid, key.remoteJidAlt);
+    addHint(key.participantAlt, key.participant);
+    addHint(key.remoteJidAlt, key.remoteJid);
+    return hints;
+};
+
+const mergeGroupDataHints = (hints, groupData, debug) => {
+    if (!groupData?.participants?.length) {
+        return;
+    }
+    debug?.('groupData-size', { participants: groupData.participants.length });
+    for (const participant of groupData.participants) {
+        const lidCandidate = participant?.lid;
+        const idCandidate = participant?.id;
+        const pnCandidate = participant?.phoneNumber;
+        const lid =
+            ((isLidUser(lidCandidate) || isHostedLidUser(lidCandidate)
+                ? lidCandidate
+                : undefined)) ||
+            ((isLidUser(idCandidate) || isHostedLidUser(idCandidate) ? idCandidate : undefined));
+        const pn =
+            ((isPnUser(pnCandidate) || isHostedPnUser(pnCandidate)
+                ? pnCandidate
+                : undefined)) ||
+            ((isPnUser(idCandidate) || isHostedPnUser(idCandidate) ? idCandidate : undefined));
+        if (!lid || !pn) {
+            continue;
+        }
+        if (
+            (isLidUser(lid) || isHostedLidUser(lid)) &&
+            (isPnUser(pn) || isHostedPnUser(pn))
+        ) {
+            const displayPn = toDisplayPnJid(pn);
+            hints.set(lid, displayPn);
+            const lidDecoded = jidDecode(lid);
+            if (lidDecoded?.user) {
+                hints.set(`${lidDecoded.user}@lid`, displayPn);
+            }
+            debug?.('group-hint', { lid, pn: displayPn });
+        }
+    }
+};
+
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    if (!isLidUser(jid) && !isHostedLidUser(jid)) {
+        return jid;
+    }
+    debug?.('input', { lid: jid });
+    const hinted = hints.get(jid);
+    if (hinted) {
+        const normalized = toDisplayPnJid(hinted);
+        debug?.('hint-exact', { lid: jid, hinted, normalized });
+        return normalized;
+    }
+    const decoded = jidDecode(jid);
+    if (decoded?.user) {
+        const userHint = hints.get(`${decoded.user}@lid`);
+        if (userHint) {
+            const normalized = toDisplayPnJid(userHint);
+            debug?.('hint-user', { lid: jid, userHint, normalized });
+            return normalized;
+        }
+    }
+    const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid);
+    if (mapped) {
+        const normalized = toDisplayPnJid(mapped);
+        debug?.('mapping', { lid: jid, mapped, normalized });
+        return normalized;
+    }
+    const fallback = fallbackPnFromLidJid(jid);
+    debug?.('fallback', { lid: jid, fallback });
+    return fallback;
+};
+
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            await normalizeMentionedJidsToPn(item, hints, signalRepository, debug);
+        }
+        return;
+    }
+    if (Array.isArray(node.mentionedJid)) {
+        const before = [...node.mentionedJid];
+        node.mentionedJid = await Promise.all(
+            node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug))
+        );
+        debug?.('mentions', { before, after: node.mentionedJid });
+    }
+    if (typeof node.participant === 'string') {
+        const before = node.participant;
+        node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug);
+        if (before !== node.participant) {
+            debug?.('participant-field', { before, after: node.participant });
+        }
+    }
+    if (typeof node.remoteJid === 'string') {
+        const before = node.remoteJid;
+        node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug);
+        if (before !== node.remoteJid) {
+            debug?.('remoteJid-field', { before, after: node.remoteJid });
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (value && typeof value === 'object') {
+            await normalizeMentionedJidsToPn(value, hints, signalRepository, debug);
+        }
+    }
+};
+
+export const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+    if (!Array.isArray(mentions)) {
+        return mentions;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = new Map();
+    mergeGroupDataHints(hints, groupData, debug);
+    const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+    debug('send-mentions-result', { before: mentions, after: normalized });
+    return normalized;
+};
+
+export const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+    if (!messageInfo?.key) {
+        return messageInfo;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = buildLidPnHints(messageInfo.key);
+    mergeGroupDataHints(hints, groupData, debug);
+    const beforeKey = { ...messageInfo.key };
+    messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug);
+    messageInfo.key.participantAlt = await normalizeToPnJid(
+        messageInfo.key.participantAlt,
+        hints,
+        signalRepository,
+        debug
+    );
+    messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug);
+    messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug);
+    await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug);
+    debug('display-key-result', { before: beforeKey, after: messageInfo.key });
+    return messageInfo;
+};

package/lib/Utils/link-preview.js

@@ -0,0 +1,84 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+        // retries
+        const retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries + 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
+        });
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};

package/lib/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,7 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/make-mutex.js

@@ -0,0 +1,32 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};