zapo-js 0.2.0 → 1.0.0

package/dist/message/addons/link-preview/detect.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstLink = findFirstLink;
+const URL_REGEX = /\bhttps?:\/\/\S+/i;
+const TRAILING_PUNCT = '.,;:!?\'"»›>';
+const WRAPPER_PAIRS = Object.freeze({
+    ')': '(',
+    ']': '[',
+    '}': '{'
+});
+function findFirstLink(text) {
+    const match = URL_REGEX.exec(text);
+    if (!match)
+        return null;
+    const raw = stripTrailing(match[0]);
+    if (raw.length === 0)
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return null;
+    return { matchedText: raw, url };
+}
+function stripTrailing(raw) {
+    let s = raw;
+    while (s.length > 0) {
+        const last = s[s.length - 1] ?? '';
+        if (TRAILING_PUNCT.includes(last)) {
+            s = s.slice(0, -1);
+            continue;
+        }
+        const opener = WRAPPER_PAIRS[last];
+        if (opener === undefined)
+            break;
+        // Only strip the closing wrapper if it's unbalanced (no matching opener
+        // inside the candidate URL). Keeps URLs like `/a_(b)` intact while
+        // still trimming `(see https://x.com)` → `https://x.com`.
+        if (countChar(s, last) > countChar(s, opener)) {
+            s = s.slice(0, -1);
+            continue;
+        }
+        break;
+    }
+    return s;
+}
+function countChar(s, ch) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === ch)
+            n++;
+    }
+    return n;
+}

package/dist/message/addons/link-preview/fetcher.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultLinkPreviewFetcher = createDefaultLinkPreviewFetcher;
+const _proto_1 = require("../../../proto.js");
+const proxy_1 = require("../../../transport/proxy");
+const bytes_1 = require("../../../util/bytes");
+const primitives_1 = require("../../../util/primitives");
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_HTML_BYTES = 65536;
+const DEFAULT_THUMBNAIL_BYTES = 262144;
+const INLINE_THUMBNAIL_MAX_BYTES = 64 * 1024;
+const MAX_REDIRECTS = 5;
+function createDefaultLinkPreviewFetcher(options) {
+    const userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    const fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxHtmlBytes = options.maxHtmlBytes ?? DEFAULT_HTML_BYTES;
+    const maxThumbnailBytes = options.maxThumbnailBytes ?? DEFAULT_THUMBNAIL_BYTES;
+    const allowPrivateHosts = options.allowPrivateHosts === true;
+    const agent = (0, proxy_1.toProxyAgent)(options.proxy);
+    const mediaTransfer = options.mediaTransfer;
+    return {
+        async fetch(input) {
+            if (!allowPrivateHosts && isPrivateHost(input.url.hostname)) {
+                input.logger.warn('link preview blocked: private host', {
+                    hostname: input.url.hostname
+                });
+                return null;
+            }
+            const minimal = {
+                matchedText: input.matchedText,
+                title: input.url.hostname,
+                previewType: _proto_1.proto.Message.ExtendedTextMessage.PreviewType.NONE
+            };
+            let html;
+            try {
+                html = await fetchHtml(input.url, {
+                    mediaTransfer,
+                    agent,
+                    userAgent,
+                    timeoutMs: fetchTimeoutMs,
+                    maxBytes: maxHtmlBytes,
+                    signal: input.signal,
+                    allowPrivateHosts
+                });
+            }
+            catch (error) {
+                input.logger.warn('link preview html fetch failed', {
+                    url: input.url.toString(),
+                    message: (0, primitives_1.toError)(error).message
+                });
+                return minimal;
+            }
+            if (html.length === 0)
+                return minimal;
+            const parsed = parseHtmlMeta(html, input.url);
+            let thumbnail;
+            if (parsed.imageUrl !== undefined) {
+                const fetched = await fetchThumbnail(parsed.imageUrl, {
+                    mediaTransfer,
+                    agent,
+                    userAgent,
+                    timeoutMs: fetchTimeoutMs,
+                    maxBytes: maxThumbnailBytes,
+                    allowPrivateHosts,
+                    signal: input.signal,
+                    logger: input.logger
+                });
+                if (fetched !== undefined) {
+                    thumbnail = {
+                        ...fetched,
+                        ...(parsed.imageWidth !== undefined ? { width: parsed.imageWidth } : {}),
+                        ...(parsed.imageHeight !== undefined ? { height: parsed.imageHeight } : {})
+                    };
+                }
+            }
+            return {
+                matchedText: input.matchedText,
+                title: parsed.title ?? input.url.hostname,
+                previewType: parsed.hasVideo
+                    ? _proto_1.proto.Message.ExtendedTextMessage.PreviewType.VIDEO
+                    : _proto_1.proto.Message.ExtendedTextMessage.PreviewType.NONE,
+                ...(parsed.description !== undefined ? { description: parsed.description } : {}),
+                ...(thumbnail !== undefined ? { thumbnail } : {})
+            };
+        }
+    };
+}
+function parseHtmlMeta(html, base) {
+    const head = extractHeadSection(html);
+    const ogTitle = extractMetaContent(head, 'property', 'og:title');
+    const twitterTitle = extractMetaContent(head, 'name', 'twitter:title');
+    const titleTag = extractTitleTag(head);
+    const ogDesc = extractMetaContent(head, 'property', 'og:description');
+    const twitterDesc = extractMetaContent(head, 'name', 'twitter:description');
+    const metaDesc = extractMetaContent(head, 'name', 'description');
+    const ogImage = extractMetaContent(head, 'property', 'og:image:secure_url') ??
+        extractMetaContent(head, 'property', 'og:image:url') ??
+        extractMetaContent(head, 'property', 'og:image') ??
+        extractMetaContent(head, 'name', 'twitter:image');
+    const ogImageWidth = (0, primitives_1.parseOptionalInt)(extractMetaContent(head, 'property', 'og:image:width'));
+    const ogImageHeight = (0, primitives_1.parseOptionalInt)(extractMetaContent(head, 'property', 'og:image:height'));
+    const ogVideo = extractMetaContent(head, 'property', 'og:video:secure_url') ??
+        extractMetaContent(head, 'property', 'og:video:url') ??
+        extractMetaContent(head, 'property', 'og:video');
+    return {
+        title: cleanText(ogTitle ?? twitterTitle ?? titleTag),
+        description: cleanText(ogDesc ?? twitterDesc ?? metaDesc),
+        imageUrl: ogImage ? toAbsoluteUrl(ogImage, base) : undefined,
+        imageWidth: ogImageWidth,
+        imageHeight: ogImageHeight,
+        hasVideo: ogVideo !== undefined
+    };
+}
+function extractHeadSection(html) {
+    const closeIdx = html.search(/<\/head\s*>/i);
+    if (closeIdx === -1)
+        return html;
+    return html.slice(0, closeIdx);
+}
+function extractMetaContent(html, attr, key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re1 = new RegExp(`<meta\\b[^>]*?\\b${attr}\\s*=\\s*["']${escaped}["'][^>]*?\\bcontent\\s*=\\s*["']([^"']*)["']`, 'i');
+    const re2 = new RegExp(`<meta\\b[^>]*?\\bcontent\\s*=\\s*["']([^"']*)["'][^>]*?\\b${attr}\\s*=\\s*["']${escaped}["']`, 'i');
+    const m = re1.exec(html) ?? re2.exec(html);
+    return m?.[1];
+}
+function extractTitleTag(html) {
+    const m = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    return m?.[1];
+}
+function cleanText(s) {
+    if (s === undefined)
+        return undefined;
+    const decoded = decodeHtmlEntities(s.replace(/\s+/g, ' ').trim());
+    return decoded.length === 0 ? undefined : decoded;
+}
+function decodeHtmlEntities(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#(\d+);/g, (_, n) => safeCodePoint(Number(n)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, hex) => safeCodePoint(Number.parseInt(hex, 16)))
+        .replace(/&amp;/g, '&');
+}
+function safeCodePoint(cp) {
+    if (!Number.isFinite(cp) || cp < 0 || cp > 0x10ffff)
+        return '';
+    return String.fromCodePoint(cp);
+}
+function toAbsoluteUrl(raw, base) {
+    try {
+        return new URL(raw, base).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fetchHtml(url, opts) {
+    const result = await httpGetWithRedirects({
+        url,
+        mediaTransfer: opts.mediaTransfer,
+        agent: opts.agent,
+        userAgent: opts.userAgent,
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        timeoutMs: opts.timeoutMs,
+        maxBytes: opts.maxBytes,
+        signal: opts.signal,
+        allowPrivateHosts: opts.allowPrivateHosts
+    });
+    if (result.status < 200 || result.status >= 300) {
+        throw new Error(`http ${result.status}`);
+    }
+    if (!/text\/html|application\/xhtml/i.test(result.contentType)) {
+        return '';
+    }
+    // HTML truncation is tolerable: the regex meta parser only needs the
+    // <head> section, which fits well below maxHtmlBytes for realistic pages.
+    return bytes_1.TEXT_DECODER.decode(result.bytes);
+}
+async function fetchThumbnail(url, opts) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return undefined;
+    if (!opts.allowPrivateHosts && isPrivateHost(parsed.hostname)) {
+        opts.logger.warn('link preview thumbnail blocked: private host', {
+            hostname: parsed.hostname
+        });
+        return undefined;
+    }
+    try {
+        const streamResult = await httpGetStreamWithRedirects({
+            url: parsed,
+            mediaTransfer: opts.mediaTransfer,
+            agent: opts.agent,
+            userAgent: opts.userAgent,
+            accept: 'image/jpeg,image/*;q=0.8',
+            timeoutMs: opts.timeoutMs,
+            signal: opts.signal,
+            allowPrivateHosts: opts.allowPrivateHosts
+        });
+        if (streamResult.status < 200 || streamResult.status >= 300) {
+            streamResult.body?.destroy();
+            return undefined;
+        }
+        if (!/^image\//i.test(streamResult.contentType)) {
+            streamResult.body?.destroy();
+            return undefined;
+        }
+        if (!streamResult.body)
+            return undefined;
+        if (streamResult.contentLength !== undefined &&
+            streamResult.contentLength > opts.maxBytes) {
+            streamResult.body.destroy();
+            return undefined;
+        }
+        if (streamResult.contentLength !== undefined &&
+            streamResult.contentLength > INLINE_THUMBNAIL_MAX_BYTES) {
+            return { stream: streamResult.body, contentLength: streamResult.contentLength };
+        }
+        const capped = await readBodyCapped(streamResult.body, opts.maxBytes);
+        if (capped.bytes.byteLength === 0)
+            return undefined;
+        // If we capped without knowing the real size, the bytes are an
+        // arbitrary prefix of the original image (corrupt JPEG/PNG). Drop it.
+        if (capped.truncated && streamResult.contentLength === undefined) {
+            opts.logger.warn('link preview thumbnail dropped: truncated without content-length', {
+                url: parsed.toString()
+            });
+            return undefined;
+        }
+        return { bytes: capped.bytes };
+    }
+    catch (error) {
+        opts.logger.warn('link preview thumbnail fetch failed', {
+            url: parsed.toString(),
+            message: (0, primitives_1.toError)(error).message
+        });
+        return undefined;
+    }
+}
+async function httpGetWithRedirects(opts) {
+    const streamResult = await httpGetStreamWithRedirects({
+        url: opts.url,
+        mediaTransfer: opts.mediaTransfer,
+        agent: opts.agent,
+        userAgent: opts.userAgent,
+        accept: opts.accept,
+        timeoutMs: opts.timeoutMs,
+        signal: opts.signal,
+        allowPrivateHosts: opts.allowPrivateHosts
+    });
+    const capped = await readBodyCapped(streamResult.body, opts.maxBytes);
+    return {
+        status: streamResult.status,
+        contentType: streamResult.contentType,
+        bytes: capped.bytes
+    };
+}
+async function httpGetStreamWithRedirects(opts) {
+    let currentUrl = opts.url;
+    for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) {
+        if (!opts.allowPrivateHosts && isPrivateHost(currentUrl.hostname)) {
+            throw new Error(`redirect to private host blocked: ${currentUrl.hostname}`);
+        }
+        const response = await opts.mediaTransfer.downloadStream({
+            url: currentUrl.toString(),
+            agent: opts.agent,
+            headers: {
+                'user-agent': opts.userAgent,
+                accept: opts.accept
+            },
+            timeoutMs: opts.timeoutMs,
+            signal: opts.signal
+        });
+        const contentType = response.headers['content-type'] ?? '';
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers['location'];
+            response.body?.destroy();
+            if (typeof location !== 'string' || location.length === 0) {
+                return {
+                    status: response.status,
+                    contentType,
+                    contentLength: undefined,
+                    body: null
+                };
+            }
+            try {
+                currentUrl = new URL(location, currentUrl);
+            }
+            catch {
+                return {
+                    status: response.status,
+                    contentType,
+                    contentLength: undefined,
+                    body: null
+                };
+            }
+            continue;
+        }
+        const contentLengthHeader = response.headers['content-length'];
+        const contentLength = (0, primitives_1.parseOptionalInt)(contentLengthHeader);
+        return {
+            status: response.status,
+            contentType,
+            contentLength,
+            body: response.body
+        };
+    }
+    throw new Error(`too many redirects (>${MAX_REDIRECTS})`);
+}
+async function readBodyCapped(body, maxBytes) {
+    if (!body)
+        return { bytes: new Uint8Array(0), truncated: false };
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    try {
+        for await (const chunk of body) {
+            const view = chunk;
+            const room = maxBytes - total;
+            if (room <= 0) {
+                truncated = true;
+                break;
+            }
+            if (view.byteLength <= room) {
+                chunks.push(view);
+                total += view.byteLength;
+            }
+            else {
+                chunks.push(view.subarray(0, room));
+                total = maxBytes;
+                truncated = true;
+                break;
+            }
+        }
+    }
+    finally {
+        body.destroy();
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { bytes: out, truncated };
+}
+const PRIVATE_IPV4 = [
+    /^127\./,
+    /^10\./,
+    /^192\.168\./,
+    /^172\.(1[6-9]|2\d|3[01])\./,
+    /^169\.254\./,
+    /^0\./
+];
+function isPrivateHost(hostname) {
+    const lower = hostname.toLowerCase();
+    // RFC 6761 §6.3: any name in the .localhost domain resolves to loopback.
+    if (lower === 'localhost' || lower.endsWith('.localhost'))
+        return true;
+    // URL.hostname strips brackets for IPv6, but tolerate either form.
+    const bare = lower.startsWith('[') && lower.endsWith(']') ? lower.slice(1, -1) : lower;
+    if (bare === '::1' || bare === '0:0:0:0:0:0:0:1' || bare === '::')
+        return true;
+    if (bare.startsWith('::ffff:')) {
+        return isPrivateHost(bare.slice('::ffff:'.length));
+    }
+    if (PRIVATE_IPV4.some((re) => re.test(bare)))
+        return true;
+    // IPv6: presence of ':' indicates an address. Match link-local (fe80::/10)
+    // and unique-local (fc00::/7) prefixes.
+    if (bare.includes(':')) {
+        if (bare.startsWith('fc') || bare.startsWith('fd'))
+            return true;
+        if (bare.startsWith('fe8') ||
+            bare.startsWith('fe9') ||
+            bare.startsWith('fea') ||
+            bare.startsWith('feb')) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/message/addons/link-preview/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/message/context-info.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContextInfoProto = buildContextInfoProto;
+exports.applyContextInfo = applyContextInfo;
+exports.pickIncomingExpirationSeconds = pickIncomingExpirationSeconds;
+exports.resolveSendContextInfo = resolveSendContextInfo;
+const jid_1 = require("../protocol/jid");
+function buildContextInfoProto(input) {
+    const ctx = {};
+    if (input.quotedMessageId !== undefined)
+        ctx.stanzaId = input.quotedMessageId;
+    if (input.quotedParticipant !== undefined)
+        ctx.participant = input.quotedParticipant;
+    if (input.quotedRemoteJid !== undefined)
+        ctx.remoteJid = input.quotedRemoteJid;
+    if (input.quotedMessage !== undefined)
+        ctx.quotedMessage = input.quotedMessage;
+    if (input.isForwarded !== undefined)
+        ctx.isForwarded = input.isForwarded;
+    if (input.forwardingScore !== undefined)
+        ctx.forwardingScore = input.forwardingScore;
+    if (input.mentionedJids && input.mentionedJids.length > 0) {
+        ctx.mentionedJid = [...input.mentionedJids];
+    }
+    if (input.isSpoiler !== undefined)
+        ctx.isSpoiler = input.isSpoiler;
+    if (input.expirationSeconds !== undefined)
+        ctx.expiration = input.expirationSeconds;
+    if (input.groupSubject !== undefined)
+        ctx.groupSubject = input.groupSubject;
+    if (input.parentGroupJid !== undefined)
+        ctx.parentGroupJid = input.parentGroupJid;
+    if (input.raw) {
+        Object.assign(ctx, input.raw);
+    }
+    return ctx;
+}
+function applyContextInfo(message, ctx) {
+    if (!ctx)
+        return message;
+    const proto = buildContextInfoProto(ctx);
+    if (!hasAnyKey(proto))
+        return message;
+    const next = { ...message };
+    if (typeof next.conversation === 'string' && !next.extendedTextMessage) {
+        next.extendedTextMessage = { text: next.conversation };
+        delete next.conversation;
+    }
+    if (!hasAnyKey(next)) {
+        next.extendedTextMessage = {};
+    }
+    const target = pickContextInfoTarget(next);
+    if (!target) {
+        throw new Error('cannot apply contextInfo: no compatible submessage found');
+    }
+    target.contextInfo = { ...target.contextInfo, ...proto };
+    return next;
+}
+/**
+ * Reads the disappearing-message TTL (`contextInfo.expiration`) from the first
+ * submessage that carries it. Unwraps `ephemeralMessage` if present. Returns
+ * `undefined` when no submessage has an `expiration` set.
+ */
+function pickIncomingExpirationSeconds(message) {
+    if (!message)
+        return undefined;
+    const inner = message.ephemeralMessage?.message ?? message;
+    for (const key of Object.keys(inner)) {
+        const value = inner[key];
+        if (value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !(value instanceof Uint8Array)) {
+            const ctx = value.contextInfo;
+            if (ctx?.expiration !== undefined && ctx.expiration !== null) {
+                return ctx.expiration;
+            }
+        }
+    }
+    return undefined;
+}
+function pickContextInfoTarget(message) {
+    for (const key of Object.keys(message)) {
+        const value = message[key];
+        if (value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !(value instanceof Uint8Array)) {
+            return value;
+        }
+    }
+    return null;
+}
+function resolveSendContextInfo(input) {
+    const ctx = {
+        ...(input.contentLevel ?? {}),
+        ...(input.optionsLevel ?? {})
+    };
+    if (input.quote) {
+        const q = input.quote;
+        ctx.quotedMessageId = q.id ?? q.key?.id ?? ctx.quotedMessageId;
+        const explicit = q.participant ?? q.key?.participant;
+        const quotedRemote = q.remoteJid ?? q.key?.remoteJid;
+        const dmFallback = explicit === undefined && quotedRemote && !(0, jid_1.isGroupOrBroadcastJid)(quotedRemote)
+            ? q.key?.fromMe
+                ? input.meLid
+                : quotedRemote
+            : undefined;
+        ctx.quotedParticipant = explicit ?? dmFallback ?? ctx.quotedParticipant;
+        ctx.quotedRemoteJid = quotedRemote ?? ctx.quotedRemoteJid;
+        ctx.quotedMessage = q.message ?? ctx.quotedMessage;
+    }
+    if (input.forward) {
+        const explicit = typeof input.forward === 'object' ? input.forward.score : undefined;
+        const base = ctx.forwardingScore ?? 0;
+        ctx.isForwarded = true;
+        ctx.forwardingScore = explicit ?? (base > 0 ? base + 1 : 1);
+    }
+    if (input.mentions?.length) {
+        ctx.mentionedJids = input.mentions;
+    }
+    return hasAnyKey(ctx) ? ctx : null;
+}
+function hasAnyKey(value) {
+    for (const _ in value) {
+        return true;
+    }
+    return false;
+}